grpc 1.60.0 → 1.61.0.pre2

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

@@ -49,7 +49,7 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "upb/base/string_view.h"
-#include "upb/upb.hpp"
+#include "upb/mem/arena.hpp"
 
 #include <grpc/byte_buffer.h>
 #include <grpc/byte_buffer_reader.h>
@@ -707,7 +707,7 @@ class RlsLb : public LoadBalancingPolicy {
   OrphanablePtr<RlsChannel> rls_channel_ ABSL_GUARDED_BY(mu_);
 
   // Accessed only from within WorkSerializer.
-  absl::StatusOr<EndpointAddressesList> addresses_;
+  absl::StatusOr<std::shared_ptr<EndpointAddressesIterator>> addresses_;
   ChannelArgs channel_args_;
   RefCountedPtr<RlsLbConfig> config_;
   RefCountedPtr<ChildPolicyWrapper> default_child_policy_;
@@ -1282,7 +1282,7 @@ RlsLb::Cache::Entry::OnRlsResponseLocked(
     auto it = lb_policy_->child_policy_map_.find(target);
     if (it == lb_policy_->child_policy_map_.end()) {
       auto new_child = MakeRefCounted<ChildPolicyWrapper>(
-          lb_policy_->Ref(DEBUG_LOCATION, "ChildPolicyWrapper"), target);
+          lb_policy_.Ref(DEBUG_LOCATION, "ChildPolicyWrapper"), target);
       new_child->StartUpdate();
       child_policies_to_finish_update.push_back(new_child.get());
       new_child_policy_wrappers.emplace_back(std::move(new_child));
@@ -1326,8 +1326,8 @@ RlsLb::Cache::Entry* RlsLb::Cache::FindOrInsert(const RequestKey& key) {
   if (it == map_.end()) {
     size_t entry_size = EntrySizeForKey(key);
     MaybeShrinkSize(size_limit_ - std::min(size_limit_, entry_size));
-    Entry* entry =
-        new Entry(lb_policy_->Ref(DEBUG_LOCATION, "CacheEntry"), key);
+    Entry* entry = new Entry(
+        lb_policy_->RefAsSubclass<RlsLb>(DEBUG_LOCATION, "CacheEntry"), key);
     map_.emplace(key, OrphanablePtr<Entry>(entry));
     size_ += entry_size;
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
@@ -1550,11 +1550,11 @@ RlsLb::RlsChannel::RlsChannel(RefCountedPtr<RlsLb> lb_policy)
     // Set up channelz linkage.
     channelz::ChannelNode* child_channelz_node =
         grpc_channel_get_channelz_node(channel_);
-    channelz::ChannelNode* parent_channelz_node =
-        lb_policy_->channel_args_.GetObject<channelz::ChannelNode>();
+    auto parent_channelz_node =
+        lb_policy_->channel_args_.GetObjectRef<channelz::ChannelNode>();
     if (child_channelz_node != nullptr && parent_channelz_node != nullptr) {
       parent_channelz_node->AddChildChannel(child_channelz_node->uuid());
-      parent_channelz_node_ = parent_channelz_node->Ref();
+      parent_channelz_node_ = std::move(parent_channelz_node);
     }
     // Start connectivity watch.
     ClientChannel* client_channel =
@@ -1607,7 +1607,7 @@ void RlsLb::RlsChannel::StartRlsCall(const RequestKey& key,
   }
   lb_policy_->request_map_.emplace(
       key, MakeOrphanable<RlsRequest>(
-               lb_policy_->Ref(DEBUG_LOCATION, "RlsRequest"), key,
+               lb_policy_.Ref(DEBUG_LOCATION, "RlsRequest"), key,
                lb_policy_->rls_channel_->Ref(DEBUG_LOCATION, "RlsRequest"),
                std::move(backoff_state), reason, std::move(stale_header_data)));
 }
@@ -1858,6 +1858,27 @@ RlsLb::RlsLb(Args args) : LoadBalancingPolicy(std::move(args)), cache_(this) {
   }
 }
 
+bool EndpointsEqual(
+    const absl::StatusOr<std::shared_ptr<EndpointAddressesIterator>> endpoints1,
+    const absl::StatusOr<std::shared_ptr<EndpointAddressesIterator>>
+        endpoints2) {
+  if (endpoints1.status() != endpoints2.status()) return false;
+  if (endpoints1.ok()) {
+    std::vector<EndpointAddresses> e1_list;
+    (*endpoints1)->ForEach([&](const EndpointAddresses& endpoint) {
+      e1_list.push_back(endpoint);
+    });
+    size_t i = 0;
+    bool different = false;
+    (*endpoints2)->ForEach([&](const EndpointAddresses& endpoint) {
+      if (endpoint != e1_list[i++]) different = true;
+    });
+    if (different) return false;
+    if (i != e1_list.size()) return false;
+  }
+  return true;
+}
+
 absl::Status RlsLb::UpdateLocked(UpdateArgs args) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
     gpr_log(GPR_INFO, "[rlslb %p] policy updated", this);
@@ -1865,7 +1886,7 @@ absl::Status RlsLb::UpdateLocked(UpdateArgs args) {
   update_in_progress_ = true;
   // Swap out config.
   RefCountedPtr<RlsLbConfig> old_config = std::move(config_);
-  config_ = std::move(args.config);
+  config_ = args.config.TakeAsSubclass<RlsLbConfig>();
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace) &&
       (old_config == nullptr ||
        old_config->child_policy_config() != config_->child_policy_config())) {
@@ -1875,7 +1896,7 @@ absl::Status RlsLb::UpdateLocked(UpdateArgs args) {
   // Swap out addresses.
   // If the new address list is an error and we have an existing address list,
   // stick with the existing addresses.
-  absl::StatusOr<EndpointAddressesList> old_addresses;
+  absl::StatusOr<std::shared_ptr<EndpointAddressesIterator>> old_addresses;
   if (args.addresses.ok()) {
     old_addresses = std::move(addresses_);
     addresses_ = std::move(args.addresses);
@@ -1888,7 +1909,7 @@ absl::Status RlsLb::UpdateLocked(UpdateArgs args) {
   bool update_child_policies =
       old_config == nullptr ||
       old_config->child_policy_config() != config_->child_policy_config() ||
-      old_addresses != addresses_ || args.args != channel_args_;
+      !EndpointsEqual(old_addresses, addresses_) || args.args != channel_args_;
   // If default target changes, swap out child policy.
   bool created_default_child = false;
   if (old_config == nullptr ||
@@ -1905,7 +1926,7 @@ absl::Status RlsLb::UpdateLocked(UpdateArgs args) {
           gpr_log(GPR_INFO, "[rlslb %p] creating new default target", this);
         }
         default_child_policy_ = MakeRefCounted<ChildPolicyWrapper>(
-            Ref(DEBUG_LOCATION, "ChildPolicyWrapper"),
+            RefAsSubclass<RlsLb>(DEBUG_LOCATION, "ChildPolicyWrapper"),
             config_->default_target());
         created_default_child = true;
       } else {
@@ -1924,8 +1945,8 @@ absl::Status RlsLb::UpdateLocked(UpdateArgs args) {
     // Swap out RLS channel if needed.
     if (old_config == nullptr ||
         config_->lookup_service() != old_config->lookup_service()) {
-      rls_channel_ =
-          MakeOrphanable<RlsChannel>(Ref(DEBUG_LOCATION, "RlsChannel"));
+      rls_channel_ = MakeOrphanable<RlsChannel>(
+          RefAsSubclass<RlsLb>(DEBUG_LOCATION, "RlsChannel"));
     }
     // Resize cache if needed.
     if (old_config == nullptr ||
@@ -2095,7 +2116,8 @@ void RlsLb::UpdatePickerLocked() {
     status = absl::UnavailableError("no children available");
   }
   channel_control_helper()->UpdateState(
-      state, status, MakeRefCounted<Picker>(Ref(DEBUG_LOCATION, "Picker")));
+      state, status,
+      MakeRefCounted<Picker>(RefAsSubclass<RlsLb>(DEBUG_LOCATION, "Picker")));
 }
 
 //

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

@@ -125,14 +125,14 @@ class OldRoundRobin : public LoadBalancingPolicy {
       : public SubchannelList<RoundRobinSubchannelList,
                               RoundRobinSubchannelData> {
    public:
-    RoundRobinSubchannelList(OldRoundRobin* policy, ServerAddressList addresses,
+    RoundRobinSubchannelList(OldRoundRobin* policy,
+                             EndpointAddressesIterator* addresses,
                              const ChannelArgs& args)
         : SubchannelList(policy,
                          (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)
                               ? "RoundRobinSubchannelList"
                               : nullptr),
-                         std::move(addresses), policy->channel_control_helper(),
-                         args) {
+                         addresses, policy->channel_control_helper(), args) {
       // Need to maintain a ref to the LB policy as long as we maintain
       // any references to subchannels, since the subchannels'
       // pollset_sets will include the LB policy's pollset_set.
@@ -277,13 +277,12 @@ void OldRoundRobin::ResetBackoffLocked() {
 }
 
 absl::Status OldRoundRobin::UpdateLocked(UpdateArgs args) {
-  ServerAddressList addresses;
+  EndpointAddressesIterator* addresses = nullptr;
   if (args.addresses.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
-      gpr_log(GPR_INFO, "[RR %p] received update with %" PRIuPTR " addresses",
-              this, args.addresses->size());
+      gpr_log(GPR_INFO, "[RR %p] received update", this);
     }
-    addresses = std::move(*args.addresses);
+    addresses = args.addresses->get();
   } else {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
       gpr_log(GPR_INFO, "[RR %p] received update with address error: %s", this,
@@ -299,8 +298,8 @@ absl::Status OldRoundRobin::UpdateLocked(UpdateArgs args) {
     gpr_log(GPR_INFO, "[RR %p] replacing previous pending subchannel list %p",
             this, latest_pending_subchannel_list_.get());
   }
-  latest_pending_subchannel_list_ = MakeRefCounted<RoundRobinSubchannelList>(
-      this, std::move(addresses), args.args);
+  latest_pending_subchannel_list_ =
+      MakeRefCounted<RoundRobinSubchannelList>(this, addresses, args.args);
   latest_pending_subchannel_list_->StartWatchingLocked(args.args);
   // If the new list is empty, immediately promote it to
   // subchannel_list_ and report TRANSIENT_FAILURE.
@@ -405,7 +404,8 @@ void OldRoundRobin::RoundRobinSubchannelList::
     }
     p->channel_control_helper()->UpdateState(
         GRPC_CHANNEL_CONNECTING, absl::Status(),
-        MakeRefCounted<QueuePicker>(p->Ref(DEBUG_LOCATION, "QueuePicker")));
+        MakeRefCounted<QueuePicker>(
+            p->RefAsSubclass<OldRoundRobin>(DEBUG_LOCATION, "QueuePicker")));
   } else if (num_transient_failure_ == num_subchannels()) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
       gpr_log(GPR_INFO,
@@ -524,14 +524,14 @@ class RoundRobin : public LoadBalancingPolicy {
   class RoundRobinEndpointList : public EndpointList {
    public:
     RoundRobinEndpointList(RefCountedPtr<RoundRobin> round_robin,
-                           const EndpointAddressesList& endpoints,
+                           EndpointAddressesIterator* endpoints,
                            const ChannelArgs& args)
         : EndpointList(std::move(round_robin),
                        GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)
                            ? "RoundRobinEndpointList"
                            : nullptr) {
       Init(endpoints, args,
-           [&](RefCountedPtr<RoundRobinEndpointList> endpoint_list,
+           [&](RefCountedPtr<EndpointList> endpoint_list,
                const EndpointAddresses& addresses, const ChannelArgs& args) {
              return MakeOrphanable<RoundRobinEndpoint>(
                  std::move(endpoint_list), addresses, args,
@@ -542,7 +542,7 @@ class RoundRobin : public LoadBalancingPolicy {
    private:
     class RoundRobinEndpoint : public Endpoint {
      public:
-      RoundRobinEndpoint(RefCountedPtr<RoundRobinEndpointList> endpoint_list,
+      RoundRobinEndpoint(RefCountedPtr<EndpointList> endpoint_list,
                          const EndpointAddresses& addresses,
                          const ChannelArgs& args,
                          std::shared_ptr<WorkSerializer> work_serializer)
@@ -687,13 +687,12 @@ void RoundRobin::ResetBackoffLocked() {
 }
 
 absl::Status RoundRobin::UpdateLocked(UpdateArgs args) {
-  EndpointAddressesList addresses;
+  EndpointAddressesIterator* addresses = nullptr;
   if (args.addresses.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
-      gpr_log(GPR_INFO, "[RR %p] received update with %" PRIuPTR " endpoints",
-              this, args.addresses->size());
+      gpr_log(GPR_INFO, "[RR %p] received update", this);
     }
-    addresses = std::move(*args.addresses);
+    addresses = args.addresses->get();
   } else {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
       gpr_log(GPR_INFO, "[RR %p] received update with address error: %s", this,
@@ -710,8 +709,8 @@ absl::Status RoundRobin::UpdateLocked(UpdateArgs args) {
             latest_pending_endpoint_list_.get());
   }
   latest_pending_endpoint_list_ = MakeOrphanable<RoundRobinEndpointList>(
-      Ref(DEBUG_LOCATION, "RoundRobinEndpointList"), std::move(addresses),
-      args.args);
+      RefAsSubclass<RoundRobin>(DEBUG_LOCATION, "RoundRobinEndpointList"),
+      addresses, args.args);
   // If the new list is empty, immediately promote it to
   // endpoint_list_ and report TRANSIENT_FAILURE.
   if (latest_pending_endpoint_list_->size() == 0) {
@@ -748,15 +747,13 @@ void RoundRobin::RoundRobinEndpointList::RoundRobinEndpoint::OnStateUpdate(
   auto* rr_endpoint_list = endpoint_list<RoundRobinEndpointList>();
   auto* round_robin = policy<RoundRobin>();
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
-    gpr_log(GPR_INFO,
-            "[RR %p] connectivity changed for child %p, endpoint_list %p "
-            "(index %" PRIuPTR " of %" PRIuPTR
-            "): prev_state=%s new_state=%s "
-            "(%s)",
-            round_robin, this, rr_endpoint_list, Index(),
-            rr_endpoint_list->size(),
-            (old_state.has_value() ? ConnectivityStateName(*old_state) : "N/A"),
-            ConnectivityStateName(new_state), status.ToString().c_str());
+    gpr_log(
+        GPR_INFO,
+        "[RR %p] connectivity changed for child %p, endpoint_list %p "
+        "(index %" PRIuPTR " of %" PRIuPTR "): prev_state=%s new_state=%s (%s)",
+        round_robin, this, rr_endpoint_list, Index(), rr_endpoint_list->size(),
+        (old_state.has_value() ? ConnectivityStateName(*old_state) : "N/A"),
+        ConnectivityStateName(new_state), status.ToString().c_str());
   }
   if (new_state == GRPC_CHANNEL_IDLE) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {

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

@@ -42,6 +42,7 @@
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
 #include "src/core/lib/load_balancing/subchannel_interface.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 #include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/transport/connectivity_state.h"
 
@@ -208,7 +209,7 @@ class SubchannelList : public DualRefCounted<SubchannelListType> {
 
  protected:
   SubchannelList(LoadBalancingPolicy* policy, const char* tracer,
-                 ServerAddressList addresses,
+                 EndpointAddressesIterator* addresses,
                  LoadBalancingPolicy::ChannelControlHelper* helper,
                  const ChannelArgs& args);
 
@@ -365,19 +366,18 @@ void SubchannelData<SubchannelListType, SubchannelDataType>::ShutdownLocked() {
 template <typename SubchannelListType, typename SubchannelDataType>
 SubchannelList<SubchannelListType, SubchannelDataType>::SubchannelList(
     LoadBalancingPolicy* policy, const char* tracer,
-    ServerAddressList addresses,
+    EndpointAddressesIterator* addresses,
     LoadBalancingPolicy::ChannelControlHelper* helper, const ChannelArgs& args)
     : DualRefCounted<SubchannelListType>(tracer),
       policy_(policy),
       tracer_(tracer) {
   if (GPR_UNLIKELY(tracer_ != nullptr)) {
-    gpr_log(GPR_INFO,
-            "[%s %p] Creating subchannel list %p for %" PRIuPTR " subchannels",
-            tracer_, policy, this, addresses.size());
+    gpr_log(GPR_INFO, "[%s %p] Creating subchannel list %p", tracer_, policy,
+            this);
   }
-  subchannels_.reserve(addresses.size());
+  if (addresses == nullptr) return;
   // Create a subchannel for each address.
-  for (ServerAddress address : addresses) {
+  addresses->ForEach([&](const EndpointAddresses& address) {
     RefCountedPtr<SubchannelInterface> subchannel =
         helper->CreateSubchannel(address.address(), address.args(), args);
     if (subchannel == nullptr) {
@@ -387,7 +387,7 @@ SubchannelList<SubchannelListType, SubchannelDataType>::SubchannelList(
                 "[%s %p] could not create subchannel for address %s, ignoring",
                 tracer_, policy_, address.ToString().c_str());
       }
-      continue;
+      return;
     }
     if (GPR_UNLIKELY(tracer_ != nullptr)) {
       gpr_log(GPR_INFO,
@@ -397,8 +397,8 @@ SubchannelList<SubchannelListType, SubchannelDataType>::SubchannelList(
               address.ToString().c_str());
     }
     subchannels_.emplace_back();
-    subchannels_.back().Init(this, std::move(address), std::move(subchannel));
-  }
+    subchannels_.back().Init(this, address, std::move(subchannel));
+  });
 }
 
 template <typename SubchannelListType, typename SubchannelDataType>

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

@@ -247,14 +247,13 @@ class OldWeightedRoundRobin : public LoadBalancingPolicy {
                               WeightedRoundRobinSubchannelData> {
    public:
     WeightedRoundRobinSubchannelList(OldWeightedRoundRobin* policy,
-                                     ServerAddressList addresses,
+                                     EndpointAddressesIterator* addresses,
                                      const ChannelArgs& args)
         : SubchannelList(policy,
                          (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)
                               ? "WeightedRoundRobinSubchannelList"
                               : nullptr),
-                         std::move(addresses), policy->channel_control_helper(),
-                         args) {
+                         addresses, policy->channel_control_helper(), args) {
       // Need to maintain a ref to the LB policy as long as we maintain
       // any references to subchannels, since the subchannels'
       // pollset_sets will include the LB policy's pollset_set.
@@ -611,10 +610,9 @@ void OldWeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
     scheduler_ = std::move(scheduler);
   }
   // Start timer.
-  WeakRefCountedPtr<Picker> self = WeakRef();
   timer_handle_ = wrr_->channel_control_helper()->GetEventEngine()->RunAfter(
       config_->weight_update_period(),
-      [self = std::move(self),
+      [self = WeakRefAsSubclass<Picker>(),
        work_serializer = wrr_->work_serializer()]() mutable {
         ApplicationCallbackExecCtx callback_exec_ctx;
         ExecCtx exec_ctx;
@@ -674,12 +672,11 @@ void OldWeightedRoundRobin::ResetBackoffLocked() {
 
 absl::Status OldWeightedRoundRobin::UpdateLocked(UpdateArgs args) {
   global_stats().IncrementWrrUpdates();
-  config_ = std::move(args.config);
-  ServerAddressList addresses;
+  config_ = args.config.TakeAsSubclass<WeightedRoundRobinConfig>();
+  std::shared_ptr<EndpointAddressesIterator> addresses;
   if (args.addresses.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-      gpr_log(GPR_INFO, "[WRR %p] received update with %" PRIuPTR " addresses",
-              this, args.addresses->size());
+      gpr_log(GPR_INFO, "[WRR %p] received update", this);
     }
     // Weed out duplicate addresses.  Also sort the addresses so that if
     // the set of the addresses don't change, their indexes in the
@@ -698,10 +695,12 @@ absl::Status OldWeightedRoundRobin::UpdateLocked(UpdateArgs args) {
         return memcmp(addr1.addr, addr2.addr, addr1.len) < 0;
       }
     };
-    std::set<ServerAddress, AddressLessThan> ordered_addresses(
-        args.addresses->begin(), args.addresses->end());
-    addresses =
-        ServerAddressList(ordered_addresses.begin(), ordered_addresses.end());
+    std::set<ServerAddress, AddressLessThan> ordered_addresses;
+    (*args.addresses)->ForEach([&](const EndpointAddresses& endpoint) {
+      ordered_addresses.insert(endpoint);
+    });
+    addresses = std::make_shared<EndpointAddressesListIterator>(
+        ServerAddressList(ordered_addresses.begin(), ordered_addresses.end()));
   } else {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
       gpr_log(GPR_INFO, "[WRR %p] received update with address error: %s", this,
@@ -718,8 +717,8 @@ absl::Status OldWeightedRoundRobin::UpdateLocked(UpdateArgs args) {
             this, latest_pending_subchannel_list_.get());
   }
   latest_pending_subchannel_list_ =
-      MakeRefCounted<WeightedRoundRobinSubchannelList>(
-          this, std::move(addresses), args.args);
+      MakeRefCounted<WeightedRoundRobinSubchannelList>(this, addresses.get(),
+                                                       args.args);
   latest_pending_subchannel_list_->StartWatchingLocked(args.args);
   // If the new list is empty, immediately promote it to
   // subchannel_list_ and report TRANSIENT_FAILURE.
@@ -757,8 +756,9 @@ OldWeightedRoundRobin::GetOrCreateWeight(const grpc_resolved_address& address) {
     auto weight = it->second->RefIfNonZero();
     if (weight != nullptr) return weight;
   }
-  auto weight =
-      MakeRefCounted<AddressWeight>(Ref(DEBUG_LOCATION, "AddressWeight"), *key);
+  auto weight = MakeRefCounted<AddressWeight>(
+      RefAsSubclass<OldWeightedRoundRobin>(DEBUG_LOCATION, "AddressWeight"),
+      *key);
   address_weight_map_.emplace(*key, weight.get());
   return weight;
 }
@@ -833,7 +833,8 @@ void OldWeightedRoundRobin::WeightedRoundRobinSubchannelList::
     }
     p->channel_control_helper()->UpdateState(
         GRPC_CHANNEL_READY, absl::Status(),
-        MakeRefCounted<Picker>(p->Ref(), this));
+        MakeRefCounted<Picker>(p->RefAsSubclass<OldWeightedRoundRobin>(),
+                               this));
   } else if (num_connecting_ > 0) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
       gpr_log(GPR_INFO, "[WRR %p] reporting CONNECTING with subchannel list %p",
@@ -1038,7 +1039,7 @@ class WeightedRoundRobin : public LoadBalancingPolicy {
    public:
     class WrrEndpoint : public Endpoint {
      public:
-      WrrEndpoint(RefCountedPtr<WrrEndpointList> endpoint_list,
+      WrrEndpoint(RefCountedPtr<EndpointList> endpoint_list,
                   const EndpointAddresses& addresses, const ChannelArgs& args,
                   std::shared_ptr<WorkSerializer> work_serializer)
           : Endpoint(std::move(endpoint_list)),
@@ -1079,14 +1080,14 @@ class WeightedRoundRobin : public LoadBalancingPolicy {
     };
 
     WrrEndpointList(RefCountedPtr<WeightedRoundRobin> wrr,
-                    const EndpointAddressesList& endpoints,
+                    EndpointAddressesIterator* endpoints,
                     const ChannelArgs& args)
         : EndpointList(std::move(wrr),
                        GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)
                            ? "WrrEndpointList"
                            : nullptr) {
       Init(endpoints, args,
-           [&](RefCountedPtr<WrrEndpointList> endpoint_list,
+           [&](RefCountedPtr<EndpointList> endpoint_list,
                const EndpointAddresses& addresses, const ChannelArgs& args) {
              return MakeOrphanable<WrrEndpoint>(
                  std::move(endpoint_list), addresses, args,
@@ -1452,10 +1453,9 @@ void WeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
     gpr_log(GPR_INFO, "[WRR %p picker %p] scheduling timer for %s", wrr_.get(),
             this, config_->weight_update_period().ToString().c_str());
   }
-  WeakRefCountedPtr<Picker> self = WeakRef();
   timer_handle_ = wrr_->channel_control_helper()->GetEventEngine()->RunAfter(
       config_->weight_update_period(),
-      [self = std::move(self),
+      [self = WeakRefAsSubclass<Picker>(),
        work_serializer = wrr_->work_serializer()]() mutable {
         ApplicationCallbackExecCtx callback_exec_ctx;
         ExecCtx exec_ctx;
@@ -1515,12 +1515,11 @@ void WeightedRoundRobin::ResetBackoffLocked() {
 
 absl::Status WeightedRoundRobin::UpdateLocked(UpdateArgs args) {
   global_stats().IncrementWrrUpdates();
-  config_ = std::move(args.config);
-  EndpointAddressesList addresses;
+  config_ = args.config.TakeAsSubclass<WeightedRoundRobinConfig>();
+  std::shared_ptr<EndpointAddressesIterator> addresses;
   if (args.addresses.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
-      gpr_log(GPR_INFO, "[WRR %p] received update with %" PRIuPTR " addresses",
-              this, args.addresses->size());
+      gpr_log(GPR_INFO, "[WRR %p] received update", this);
     }
     // Weed out duplicate endpoints.  Also sort the endpoints so that if
     // the set of endpoints doesn't change, their indexes in the endpoint
@@ -1539,10 +1538,13 @@ absl::Status WeightedRoundRobin::UpdateLocked(UpdateArgs args) {
         return e1 < e2;
       }
     };
-    std::set<EndpointAddresses, EndpointAddressesLessThan> ordered_addresses(
-        args.addresses->begin(), args.addresses->end());
-    addresses = EndpointAddressesList(ordered_addresses.begin(),
-                                      ordered_addresses.end());
+    std::set<EndpointAddresses, EndpointAddressesLessThan> ordered_addresses;
+    (*args.addresses)->ForEach([&](const EndpointAddresses& endpoint) {
+      ordered_addresses.insert(endpoint);
+    });
+    addresses =
+        std::make_shared<EndpointAddressesListIterator>(EndpointAddressesList(
+            ordered_addresses.begin(), ordered_addresses.end()));
   } else {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
       gpr_log(GPR_INFO, "[WRR %p] received update with address error: %s", this,
@@ -1558,8 +1560,8 @@ absl::Status WeightedRoundRobin::UpdateLocked(UpdateArgs args) {
     gpr_log(GPR_INFO, "[WRR %p] replacing previous pending endpoint list %p",
             this, latest_pending_endpoint_list_.get());
   }
-  latest_pending_endpoint_list_ =
-      MakeOrphanable<WrrEndpointList>(Ref(), std::move(addresses), args.args);
+  latest_pending_endpoint_list_ = MakeOrphanable<WrrEndpointList>(
+      RefAsSubclass<WeightedRoundRobin>(), addresses.get(), args.args);
   // If the new list is empty, immediately promote it to
   // endpoint_list_ and report TRANSIENT_FAILURE.
   if (latest_pending_endpoint_list_->size() == 0) {
@@ -1597,7 +1599,7 @@ WeightedRoundRobin::GetOrCreateWeight(
     if (weight != nullptr) return weight;
   }
   auto weight = MakeRefCounted<EndpointWeight>(
-      Ref(DEBUG_LOCATION, "EndpointWeight"), key);
+      RefAsSubclass<WeightedRoundRobin>(DEBUG_LOCATION, "EndpointWeight"), key);
   endpoint_weight_map_.emplace(key, weight.get());
   return weight;
 }
@@ -1757,7 +1759,7 @@ void WeightedRoundRobin::WrrEndpointList::
     }
     wrr->channel_control_helper()->UpdateState(
         GRPC_CHANNEL_READY, absl::Status(),
-        MakeRefCounted<Picker>(wrr->Ref(), this));
+        MakeRefCounted<Picker>(wrr->RefAsSubclass<WeightedRoundRobin>(), this));
   } else if (num_connecting_ > 0) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_wrr_trace)) {
       gpr_log(GPR_INFO, "[WRR %p] reporting CONNECTING with endpoint list %p",

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

@@ -157,10 +157,10 @@ class WeightedTargetLb : public LoadBalancingPolicy {
 
     void Orphan() override;
 
-    absl::Status UpdateLocked(const WeightedTargetLbConfig::ChildConfig& config,
-                              absl::StatusOr<EndpointAddressesList> addresses,
-                              const std::string& resolution_note,
-                              const ChannelArgs& args);
+    absl::Status UpdateLocked(
+        const WeightedTargetLbConfig::ChildConfig& config,
+        absl::StatusOr<std::shared_ptr<EndpointAddressesIterator>> addresses,
+        const std::string& resolution_note, const ChannelArgs& args);
     void ResetBackoffLocked();
     void DeactivateLocked();
 
@@ -316,7 +316,7 @@ absl::Status WeightedTargetLb::UpdateLocked(UpdateArgs args) {
   }
   update_in_progress_ = true;
   // Update config.
-  config_ = std::move(args.config);
+  config_ = args.config.TakeAsSubclass<WeightedTargetLbConfig>();
   // Deactivate the targets not in the new config.
   for (const auto& p : targets_) {
     const std::string& name = p.first;
@@ -336,13 +336,15 @@ absl::Status WeightedTargetLb::UpdateLocked(UpdateArgs args) {
     // Create child if it does not already exist.
     if (target == nullptr) {
       target = MakeOrphanable<WeightedChild>(
-          Ref(DEBUG_LOCATION, "WeightedChild"), name);
+          RefAsSubclass<WeightedTargetLb>(DEBUG_LOCATION, "WeightedChild"),
+          name);
     }
-    absl::StatusOr<EndpointAddressesList> addresses;
+    absl::StatusOr<std::shared_ptr<EndpointAddressesIterator>> addresses;
     if (address_map.ok()) {
       auto it = address_map->find(name);
       if (it == address_map->end()) {
-        addresses.emplace();
+        addresses = std::make_shared<EndpointAddressesListIterator>(
+            EndpointAddressesList());
       } else {
         addresses = std::move(it->second);
       }
@@ -589,7 +591,7 @@ WeightedTargetLb::WeightedChild::CreateChildPolicyLocked(
 
 absl::Status WeightedTargetLb::WeightedChild::UpdateLocked(
     const WeightedTargetLbConfig::ChildConfig& config,
-    absl::StatusOr<EndpointAddressesList> addresses,
+    absl::StatusOr<std::shared_ptr<EndpointAddressesIterator>> addresses,
     const std::string& resolution_note, const ChannelArgs& args) {
   if (weighted_target_policy_->shutting_down_) return absl::OkStatus();
   // Update child weight.