grpc 1.60.2 → 1.61.0.pre2

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

@@ -28,7 +28,7 @@
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "google/protobuf/duration.upb.h"
-#include "upb/upb.hpp"
+#include "upb/mem/arena.hpp"
 #include "xds/service/orca/v3/orca.upb.h"
 
 #include <grpc/impl/connectivity_state.h>
@@ -215,7 +215,8 @@ class OrcaProducer::OrcaStreamEventHandler
 void OrcaProducer::Start(RefCountedPtr<Subchannel> subchannel) {
   subchannel_ = std::move(subchannel);
   connected_subchannel_ = subchannel_->connected_subchannel();
-  auto connectivity_watcher = MakeRefCounted<ConnectivityWatcher>(WeakRef());
+  auto connectivity_watcher =
+      MakeRefCounted<ConnectivityWatcher>(WeakRefAsSubclass<OrcaProducer>());
   connectivity_watcher_ = connectivity_watcher.get();
   subchannel_->WatchConnectivityState(std::move(connectivity_watcher));
 }
@@ -269,7 +270,8 @@ void OrcaProducer::MaybeStartStreamLocked() {
   if (connected_subchannel_ == nullptr) return;
   stream_client_ = MakeOrphanable<SubchannelStreamClient>(
       connected_subchannel_, subchannel_->pollset_set(),
-      std::make_unique<OrcaStreamEventHandler>(WeakRef(), report_interval_),
+      std::make_unique<OrcaStreamEventHandler>(
+          WeakRefAsSubclass<OrcaProducer>(), report_interval_),
       GRPC_TRACE_FLAG_ENABLED(grpc_orca_client_trace) ? "OrcaClient" : nullptr);
 }
 
@@ -310,7 +312,10 @@ void OrcaWatcher::SetSubchannel(Subchannel* subchannel) {
   // If not, create a new one.
   subchannel->GetOrAddDataProducer(
       OrcaProducer::Type(), [&](Subchannel::DataProducerInterface** producer) {
-        if (*producer != nullptr) producer_ = (*producer)->RefIfNonZero();
+        if (*producer != nullptr) {
+          producer_ =
+              (*producer)->RefIfNonZero().TakeAsSubclass<OrcaProducer>();
+        }
         if (producer_ == nullptr) {
           producer_ = MakeRefCounted<OrcaProducer>();
           *producer = producer_.get();

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

@@ -151,9 +151,8 @@ class OutlierDetectionLb : public LoadBalancingPolicy {
         }
         return;
       }
-      WeakRefCountedPtr<SubchannelWrapper> self = WeakRef();
       work_serializer_->Run(
-          [self = std::move(self)]() {
+          [self = WeakRefAsSubclass<SubchannelWrapper>()]() {
             if (self->subchannel_state_ != nullptr) {
               self->subchannel_state_->RemoveSubchannel(self.get());
             }
@@ -624,7 +623,7 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
   }
   auto old_config = std::move(config_);
   // Update config.
-  config_ = std::move(args.config);
+  config_ = args.config.TakeAsSubclass<OutlierDetectionLbConfig>();
   // Update outlier detection timer.
   if (!config_->CountingEnabled()) {
     // No need for timer.  Cancel the current timer, if any.
@@ -639,7 +638,8 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
       gpr_log(GPR_INFO, "[outlier_detection_lb %p] starting timer", this);
     }
-    ejection_timer_ = MakeOrphanable<EjectionTimer>(Ref(), Timestamp::Now());
+    ejection_timer_ = MakeOrphanable<EjectionTimer>(
+        RefAsSubclass<OutlierDetectionLb>(), Timestamp::Now());
     for (const auto& p : endpoint_state_map_) {
       p.second->RotateBucket();  // Reset call counters.
     }
@@ -654,14 +654,14 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
               "[outlier_detection_lb %p] interval changed, replacing timer",
               this);
     }
-    ejection_timer_ =
-        MakeOrphanable<EjectionTimer>(Ref(), ejection_timer_->StartTime());
+    ejection_timer_ = MakeOrphanable<EjectionTimer>(
+        RefAsSubclass<OutlierDetectionLb>(), ejection_timer_->StartTime());
   }
   // Update subchannel and endpoint maps.
   if (args.addresses.ok()) {
     std::set<EndpointAddressSet> current_endpoints;
     std::set<grpc_resolved_address, ResolvedAddressLessThan> current_addresses;
-    for (const EndpointAddresses& endpoint : *args.addresses) {
+    (*args.addresses)->ForEach([&](const EndpointAddresses& endpoint) {
       EndpointAddressSet key(endpoint.addresses());
       current_endpoints.emplace(key);
       for (const grpc_resolved_address& address : endpoint.addresses()) {
@@ -708,7 +708,7 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
         }
         it->second->DisableEjection();
       }
-    }
+    });
     // Remove any entries we no longer need in the subchannel map.
     for (auto it = subchannel_state_map_.begin();
          it != subchannel_state_map_.end();) {
@@ -753,7 +753,6 @@ absl::Status OutlierDetectionLb::UpdateLocked(UpdateArgs args) {
   update_args.addresses = std::move(args.addresses);
   update_args.resolution_note = std::move(args.resolution_note);
   update_args.config = config_->child_policy();
-  // Update the policy.
   update_args.args = std::move(args.args);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_outlier_detection_lb_trace)) {
     gpr_log(GPR_INFO,
@@ -784,8 +783,8 @@ OrphanablePtr<LoadBalancingPolicy> OutlierDetectionLb::CreateChildPolicyLocked(
   LoadBalancingPolicy::Args lb_policy_args;
   lb_policy_args.work_serializer = work_serializer();
   lb_policy_args.args = args;
-  lb_policy_args.channel_control_helper =
-      std::make_unique<Helper>(Ref(DEBUG_LOCATION, "Helper"));
+  lb_policy_args.channel_control_helper = std::make_unique<Helper>(
+      RefAsSubclass<OutlierDetectionLb>(DEBUG_LOCATION, "Helper"));
   OrphanablePtr<LoadBalancingPolicy> lb_policy =
       MakeOrphanable<ChildPolicyHandler>(std::move(lb_policy_args),
                                          &grpc_outlier_detection_lb_trace);

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

@@ -21,7 +21,6 @@
 #include <inttypes.h>
 #include <string.h>
 
-#include <algorithm>
 #include <memory>
 #include <set>
 #include <string>
@@ -114,7 +113,7 @@ class PickFirst : public LoadBalancingPolicy {
    public:
     class SubchannelData {
      public:
-      SubchannelData(SubchannelList* subchannel_list,
+      SubchannelData(SubchannelList* subchannel_list, size_t index,
                      RefCountedPtr<SubchannelInterface> subchannel);
 
       SubchannelInterface* subchannel() const { return subchannel_.get(); }
@@ -125,12 +124,6 @@ class PickFirst : public LoadBalancingPolicy {
         return connectivity_status_;
       }
 
-      // Returns the index into the subchannel list of this object.
-      size_t Index() const {
-        return static_cast<size_t>(this -
-                                   &subchannel_list_->subchannels_.front());
-      }
-
       // Resets the connection backoff.
       void ResetBackoffLocked() {
         if (subchannel_ != nullptr) subchannel_->ResetBackoff();
@@ -153,10 +146,8 @@ class PickFirst : public LoadBalancingPolicy {
       class Watcher
           : public SubchannelInterface::ConnectivityStateWatcherInterface {
        public:
-        Watcher(SubchannelData* subchannel_data,
-                RefCountedPtr<SubchannelList> subchannel_list)
-            : subchannel_data_(subchannel_data),
-              subchannel_list_(std::move(subchannel_list)) {}
+        Watcher(RefCountedPtr<SubchannelList> subchannel_list, size_t index)
+            : subchannel_list_(std::move(subchannel_list)), index_(index) {}
 
         ~Watcher() override {
           subchannel_list_.reset(DEBUG_LOCATION, "Watcher dtor");
@@ -164,8 +155,8 @@ class PickFirst : public LoadBalancingPolicy {
 
         void OnConnectivityStateChange(grpc_connectivity_state new_state,
                                        absl::Status status) override {
-          subchannel_data_->OnConnectivityStateChange(new_state,
-                                                      std::move(status));
+          subchannel_list_->subchannels_[index_].OnConnectivityStateChange(
+              new_state, std::move(status));
         }
 
         grpc_pollset_set* interested_parties() override {
@@ -173,8 +164,8 @@ class PickFirst : public LoadBalancingPolicy {
         }
 
        private:
-        SubchannelData* subchannel_data_;
         RefCountedPtr<SubchannelList> subchannel_list_;
+        const size_t index_;
       };
 
       // This method will be invoked once soon after instantiation to report
@@ -193,6 +184,7 @@ class PickFirst : public LoadBalancingPolicy {
 
       // Backpointer to owning subchannel list.  Not owned.
       SubchannelList* subchannel_list_;
+      const size_t index_;
       // The subchannel.
       RefCountedPtr<SubchannelInterface> subchannel_;
       // Will be non-null when the subchannel's state is being watched.
@@ -205,7 +197,8 @@ class PickFirst : public LoadBalancingPolicy {
     };
 
     SubchannelList(RefCountedPtr<PickFirst> policy,
-                   EndpointAddressesList addresses, const ChannelArgs& args);
+                   EndpointAddressesIterator* addresses,
+                   const ChannelArgs& args);
 
     ~SubchannelList() override;
 
@@ -231,7 +224,9 @@ class PickFirst : public LoadBalancingPolicy {
    private:
     // Returns true if all subchannels have seen their initial
     // connectivity state notifications.
-    bool AllSubchannelsSeenInitialState();
+    bool AllSubchannelsSeenInitialState() const {
+      return num_subchannels_seen_initial_notification_ == size();
+    }
 
     // Looks through subchannels_ starting from attempting_index_ to
     // find the first one not currently in TRANSIENT_FAILURE, then
@@ -262,6 +257,8 @@ class PickFirst : public LoadBalancingPolicy {
     // TODO(roth): Remove this when we remove the Happy Eyeballs experiment.
     bool in_transient_failure_ = false;
 
+    size_t num_subchannels_seen_initial_notification_ = 0;
+
     // The index into subchannels_ to which we are currently attempting
     // to connect during the initial Happy Eyeballs pass.  Once the
     // initial pass is over, this will be equal to size().
@@ -413,9 +410,9 @@ void PickFirst::ResetBackoffLocked() {
 
 void PickFirst::AttemptToConnectUsingLatestUpdateArgsLocked() {
   // Create a subchannel list from latest_update_args_.
-  EndpointAddressesList addresses;
+  EndpointAddressesIterator* addresses = nullptr;
   if (latest_update_args_.addresses.ok()) {
-    addresses = *latest_update_args_.addresses;
+    addresses = latest_update_args_.addresses->get();
   }
   // Replace latest_pending_subchannel_list_.
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_pick_first_trace) &&
@@ -425,7 +422,7 @@ void PickFirst::AttemptToConnectUsingLatestUpdateArgsLocked() {
             latest_pending_subchannel_list_.get());
   }
   latest_pending_subchannel_list_ = MakeOrphanable<SubchannelList>(
-      Ref(), std::move(addresses), latest_update_args_.args);
+      RefAsSubclass<PickFirst>(), addresses, latest_update_args_.args);
   // Empty update or no valid subchannels.  Put the channel in
   // TRANSIENT_FAILURE and request re-resolution.
   if (latest_pending_subchannel_list_->size() == 0) {
@@ -483,9 +480,7 @@ class AddressFamilyIterator {
 absl::Status PickFirst::UpdateLocked(UpdateArgs args) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_pick_first_trace)) {
     if (args.addresses.ok()) {
-      gpr_log(GPR_INFO,
-              "Pick First %p received update with %" PRIuPTR " addresses", this,
-              args.addresses->size());
+      gpr_log(GPR_INFO, "Pick First %p received update", this);
     } else {
       gpr_log(GPR_INFO, "Pick First %p received update with address error: %s",
               this, args.addresses.status().ToString().c_str());
@@ -495,51 +490,59 @@ absl::Status PickFirst::UpdateLocked(UpdateArgs args) {
   absl::Status status;
   if (!args.addresses.ok()) {
     status = args.addresses.status();
-  } else if (args.addresses->empty()) {
-    status = absl::UnavailableError("address list must not be empty");
   } else {
-    // Shuffle the list if needed.
-    auto config = static_cast<PickFirstConfig*>(args.config.get());
-    if (config->shuffle_addresses()) {
-      absl::c_shuffle(*args.addresses, bit_gen_);
-    }
-    // Flatten the list so that we have one address per endpoint.
-    // While we're iterating, also determine the desired address family
-    // order and the index of the first element of each family, for use in
-    // the interleaving below.
-    std::set<absl::string_view> address_families;
-    std::vector<AddressFamilyIterator> address_family_order;
     EndpointAddressesList endpoints;
-    for (const auto& endpoint : *args.addresses) {
-      for (const auto& address : endpoint.addresses()) {
-        endpoints.emplace_back(address, endpoint.args());
-        if (IsPickFirstHappyEyeballsEnabled()) {
-          absl::string_view scheme = GetAddressFamily(address);
-          bool inserted = address_families.insert(scheme).second;
-          if (inserted) {
-            address_family_order.emplace_back(scheme, endpoints.size() - 1);
+    (*args.addresses)->ForEach([&](const EndpointAddresses& endpoint) {
+      endpoints.push_back(endpoint);
+    });
+    if (endpoints.empty()) {
+      status = absl::UnavailableError("address list must not be empty");
+    } else {
+      // Shuffle the list if needed.
+      auto config = static_cast<PickFirstConfig*>(args.config.get());
+      if (config->shuffle_addresses()) {
+        absl::c_shuffle(endpoints, bit_gen_);
+      }
+      // Flatten the list so that we have one address per endpoint.
+      // While we're iterating, also determine the desired address family
+      // order and the index of the first element of each family, for use in
+      // the interleaving below.
+      std::set<absl::string_view> address_families;
+      std::vector<AddressFamilyIterator> address_family_order;
+      EndpointAddressesList flattened_endpoints;
+      for (const auto& endpoint : endpoints) {
+        for (const auto& address : endpoint.addresses()) {
+          flattened_endpoints.emplace_back(address, endpoint.args());
+          if (IsPickFirstHappyEyeballsEnabled()) {
+            absl::string_view scheme = GetAddressFamily(address);
+            bool inserted = address_families.insert(scheme).second;
+            if (inserted) {
+              address_family_order.emplace_back(scheme,
+                                                flattened_endpoints.size() - 1);
+            }
           }
         }
       }
-    }
-    // Interleave addresses as per RFC-8305 section 4.
-    if (IsPickFirstHappyEyeballsEnabled()) {
-      EndpointAddressesList interleaved_endpoints;
-      interleaved_endpoints.reserve(endpoints.size());
-      std::vector<bool> endpoints_moved(endpoints.size());
-      size_t scheme_index = 0;
-      for (size_t i = 0; i < endpoints.size(); ++i) {
-        EndpointAddresses* endpoint;
-        do {
-          auto& iterator = address_family_order[scheme_index++ %
-                                                address_family_order.size()];
-          endpoint = iterator.Next(endpoints, &endpoints_moved);
-        } while (endpoint == nullptr);
-        interleaved_endpoints.emplace_back(std::move(*endpoint));
+      endpoints = std::move(flattened_endpoints);
+      // Interleave addresses as per RFC-8305 section 4.
+      if (IsPickFirstHappyEyeballsEnabled()) {
+        EndpointAddressesList interleaved_endpoints;
+        interleaved_endpoints.reserve(endpoints.size());
+        std::vector<bool> endpoints_moved(endpoints.size());
+        size_t scheme_index = 0;
+        for (size_t i = 0; i < endpoints.size(); ++i) {
+          EndpointAddresses* endpoint;
+          do {
+            auto& iterator = address_family_order[scheme_index++ %
+                                                  address_family_order.size()];
+            endpoint = iterator.Next(endpoints, &endpoints_moved);
+          } while (endpoint == nullptr);
+          interleaved_endpoints.emplace_back(std::move(*endpoint));
+        }
+        endpoints = std::move(interleaved_endpoints);
       }
-      args.addresses = std::move(interleaved_endpoints);
-    } else {
-      args.addresses = std::move(endpoints);
+      args.addresses =
+          std::make_shared<EndpointAddressesListIterator>(std::move(endpoints));
     }
   }
   // If the update contains a resolver error and we have a previous update
@@ -617,18 +620,20 @@ void PickFirst::HealthWatcher::OnConnectivityStateChange(
 //
 
 PickFirst::SubchannelList::SubchannelData::SubchannelData(
-    SubchannelList* subchannel_list,
+    SubchannelList* subchannel_list, size_t index,
     RefCountedPtr<SubchannelInterface> subchannel)
-    : subchannel_list_(subchannel_list), subchannel_(std::move(subchannel)) {
+    : subchannel_list_(subchannel_list),
+      index_(index),
+      subchannel_(std::move(subchannel)) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_pick_first_trace)) {
     gpr_log(GPR_INFO,
             "[PF %p] subchannel list %p index %" PRIuPTR
             " (subchannel %p): starting watch",
-            subchannel_list_->policy_.get(), subchannel_list_,
-            subchannel_list_->size(), subchannel_.get());
+            subchannel_list_->policy_.get(), subchannel_list_, index_,
+            subchannel_.get());
   }
   auto watcher = std::make_unique<Watcher>(
-      this, subchannel_list_->Ref(DEBUG_LOCATION, "Watcher"));
+      subchannel_list_->Ref(DEBUG_LOCATION, "Watcher"), index_);
   pending_watcher_ = watcher.get();
   subchannel_->WatchConnectivityState(std::move(watcher));
 }
@@ -639,7 +644,7 @@ void PickFirst::SubchannelList::SubchannelData::ShutdownLocked() {
       gpr_log(GPR_INFO,
               "[PF %p] subchannel list %p index %" PRIuPTR " of %" PRIuPTR
               " (subchannel %p): cancelling watch and unreffing subchannel",
-              subchannel_list_->policy_.get(), subchannel_list_, Index(),
+              subchannel_list_->policy_.get(), subchannel_list_, index_,
               subchannel_list_->size(), subchannel_.get());
     }
     subchannel_->CancelConnectivityStateWatch(pending_watcher_);
@@ -659,7 +664,7 @@ void PickFirst::SubchannelList::SubchannelData::OnConnectivityStateChange(
         "status=%s, shutting_down=%d, pending_watcher=%p, "
         "seen_transient_failure=%d, p->selected_=%p, "
         "p->subchannel_list_=%p, p->latest_pending_subchannel_list_=%p",
-        p, subchannel_list_, Index(), subchannel_list_->size(),
+        p, subchannel_list_, index_, subchannel_list_->size(),
         subchannel_.get(),
         (connectivity_state_.has_value()
              ? ConnectivityStateName(*connectivity_state_)
@@ -753,6 +758,11 @@ void PickFirst::SubchannelList::SubchannelData::OnConnectivityStateChange(
     seen_transient_failure_ = true;
     subchannel_list_->last_failure_ = connectivity_status_;
   }
+  // If this is the initial connectivity state update for this subchannel,
+  // increment the counter in the subchannel list.
+  if (!old_state.has_value()) {
+    ++subchannel_list_->num_subchannels_seen_initial_notification_;
+  }
   // If we haven't yet seen the initial connectivity state notification
   // for all subchannels, do nothing.
   if (!subchannel_list_->AllSubchannelsSeenInitialState()) return;
@@ -771,7 +781,7 @@ void PickFirst::SubchannelList::SubchannelData::OnConnectivityStateChange(
   if (!IsPickFirstHappyEyeballsEnabled()) {
     // Ignore any other updates for subchannels we're not currently trying to
     // connect to.
-    if (Index() != subchannel_list_->attempting_index_) return;
+    if (index_ != subchannel_list_->attempting_index_) return;
     // React to the connectivity state.
     ReactToConnectivityStateLocked();
     return;
@@ -784,7 +794,7 @@ void PickFirst::SubchannelList::SubchannelData::OnConnectivityStateChange(
       if (!prev_seen_transient_failure && seen_transient_failure_) {
         // If a connection attempt fails before the timer fires, then
         // cancel the timer and start connecting on the next subchannel.
-        if (Index() == subchannel_list_->attempting_index_) {
+        if (index_ == subchannel_list_->attempting_index_) {
           if (subchannel_list_->timer_handle_.has_value()) {
             p->channel_control_helper()->GetEventEngine()->Cancel(
                 *subchannel_list_->timer_handle_);
@@ -858,7 +868,7 @@ void PickFirst::SubchannelList::SubchannelData::
       // We skip subchannels in state TRANSIENT_FAILURE to avoid a
       // large recursion that could overflow the stack.
       SubchannelData* found_subchannel = nullptr;
-      for (size_t next_index = Index() + 1;
+      for (size_t next_index = index_ + 1;
            next_index < subchannel_list_->size(); ++next_index) {
         SubchannelData* sc = &subchannel_list_->subchannels_[next_index];
         GPR_ASSERT(sc->connectivity_state_.has_value());
@@ -946,14 +956,14 @@ void PickFirst::SubchannelList::SubchannelData::RequestConnectionWithTimer() {
     GPR_ASSERT(connectivity_state_ == GRPC_CHANNEL_CONNECTING);
   }
   // If this is not the last subchannel in the list, start the timer.
-  if (Index() != subchannel_list_->size() - 1) {
+  if (index_ != subchannel_list_->size() - 1) {
     PickFirst* p = subchannel_list_->policy_.get();
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_pick_first_trace)) {
       gpr_log(GPR_INFO,
               "Pick First %p subchannel list %p: starting Connection "
               "Attempt Delay timer for %" PRId64 "ms for index %" PRIuPTR,
               p, subchannel_list_, p->connection_attempt_delay_.millis(),
-              Index());
+              index_);
     }
     subchannel_list_->timer_handle_ =
         p->channel_control_helper()->GetEventEngine()->RunAfter(
@@ -1029,7 +1039,7 @@ void PickFirst::SubchannelList::SubchannelData::ProcessUnselectedReadyLocked() {
       gpr_log(GPR_INFO, "[PF %p] starting health watch", p);
     }
     auto watcher = std::make_unique<HealthWatcher>(
-        p->Ref(DEBUG_LOCATION, "HealthWatcher"));
+        p->RefAsSubclass<PickFirst>(DEBUG_LOCATION, "HealthWatcher"));
     p->health_watcher_ = watcher.get();
     auto health_data_watcher = MakeHealthCheckWatcher(
         p->work_serializer(), subchannel_list_->args_, std::move(watcher));
@@ -1041,7 +1051,7 @@ void PickFirst::SubchannelList::SubchannelData::ProcessUnselectedReadyLocked() {
   }
   // Unref all other subchannels in the list.
   for (size_t i = 0; i < subchannel_list_->size(); ++i) {
-    if (i != Index()) {
+    if (i != index_) {
       subchannel_list_->subchannels_[i].ShutdownLocked();
     }
   }
@@ -1052,7 +1062,7 @@ void PickFirst::SubchannelList::SubchannelData::ProcessUnselectedReadyLocked() {
 //
 
 PickFirst::SubchannelList::SubchannelList(RefCountedPtr<PickFirst> policy,
-                                          EndpointAddressesList addresses,
+                                          EndpointAddressesIterator* addresses,
                                           const ChannelArgs& args)
     : InternallyRefCounted<SubchannelList>(
           GRPC_TRACE_FLAG_ENABLED(grpc_lb_pick_first_trace) ? "SubchannelList"
@@ -1062,14 +1072,12 @@ PickFirst::SubchannelList::SubchannelList(RefCountedPtr<PickFirst> policy,
                 .Remove(
                     GRPC_ARG_INTERNAL_PICK_FIRST_OMIT_STATUS_MESSAGE_PREFIX)) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_pick_first_trace)) {
-    gpr_log(GPR_INFO,
-            "[PF %p] Creating subchannel list %p for %" PRIuPTR
-            " subchannels - channel args: %s",
-            policy_.get(), this, addresses.size(), args_.ToString().c_str());
+    gpr_log(GPR_INFO, "[PF %p] Creating subchannel list %p - channel args: %s",
+            policy_.get(), this, args_.ToString().c_str());
   }
-  subchannels_.reserve(addresses.size());
+  if (addresses == nullptr) return;
   // Create a subchannel for each address.
-  for (const EndpointAddresses& address : addresses) {
+  addresses->ForEach([&](const EndpointAddresses& address) {
     GPR_ASSERT(address.addresses().size() == 1);
     RefCountedPtr<SubchannelInterface> subchannel =
         policy_->channel_control_helper()->CreateSubchannel(
@@ -1081,7 +1089,7 @@ PickFirst::SubchannelList::SubchannelList(RefCountedPtr<PickFirst> policy,
                 "[PF %p] could not create subchannel for address %s, ignoring",
                 policy_.get(), address.ToString().c_str());
       }
-      continue;
+      return;
     }
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_pick_first_trace)) {
       gpr_log(GPR_INFO,
@@ -1090,8 +1098,8 @@ PickFirst::SubchannelList::SubchannelList(RefCountedPtr<PickFirst> policy,
               policy_.get(), this, subchannels_.size(), subchannel.get(),
               address.ToString().c_str());
     }
-    subchannels_.emplace_back(this, std::move(subchannel));
-  }
+    subchannels_.emplace_back(this, subchannels_.size(), std::move(subchannel));
+  });
 }
 
 PickFirst::SubchannelList::~SubchannelList() {
@@ -1123,13 +1131,6 @@ void PickFirst::SubchannelList::ResetBackoffLocked() {
   }
 }
 
-bool PickFirst::SubchannelList::AllSubchannelsSeenInitialState() {
-  for (auto& sd : subchannels_) {
-    if (!sd.connectivity_state().has_value()) return false;
-  }
-  return true;
-}
-
 void PickFirst::SubchannelList::StartConnectingNextSubchannel() {
   // Find the next subchannel not in state TRANSIENT_FAILURE.
   // We skip subchannels in state TRANSIENT_FAILURE to avoid a

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

@@ -335,7 +335,7 @@ absl::Status PriorityLb::UpdateLocked(UpdateArgs args) {
     gpr_log(GPR_INFO, "[priority_lb %p] received update", this);
   }
   // Update config.
-  config_ = std::move(args.config);
+  config_ = args.config.TakeAsSubclass<PriorityLbConfig>();
   // Update args.
   args_ = std::move(args.args);
   // Update addresses.
@@ -411,7 +411,8 @@ void PriorityLb::ChoosePriorityLocked() {
     // Create child if needed.
     if (child == nullptr) {
       child = MakeOrphanable<ChildPriority>(
-          Ref(DEBUG_LOCATION, "ChildPriority"), child_name);
+          RefAsSubclass<PriorityLb>(DEBUG_LOCATION, "ChildPriority"),
+          child_name);
       auto child_config = config_->children().find(child_name);
       GPR_DEBUG_ASSERT(child_config != config_->children().end());
       // TODO(roth): If the child reports a non-OK status with the
@@ -684,7 +685,8 @@ absl::Status PriorityLb::ChildPriority::UpdateLocked(
   if (priority_policy_->addresses_.ok()) {
     auto it = priority_policy_->addresses_->find(name_);
     if (it == priority_policy_->addresses_->end()) {
-      update_args.addresses.emplace();
+      update_args.addresses = std::make_shared<EndpointAddressesListIterator>(
+          EndpointAddressesList());
     } else {
       update_args.addresses = it->second;
     }

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

@@ -346,7 +346,7 @@ RingHash::PickResult RingHash::Picker::Pick(PickArgs args) {
         return endpoint_info.picker->Pick(args);
       case GRPC_CHANNEL_IDLE:
         new EndpointConnectionAttempter(
-            ring_hash_->Ref(DEBUG_LOCATION, "EndpointConnectionAttempter"),
+            ring_hash_.Ref(DEBUG_LOCATION, "EndpointConnectionAttempter"),
             endpoint_info.endpoint);
         ABSL_FALLTHROUGH_INTENDED;
       case GRPC_CHANNEL_CONNECTING:
@@ -554,7 +554,8 @@ void RingHash::RingHashEndpoint::UpdateChildPolicyLocked() {
   GPR_ASSERT(config.ok());
   // Update child policy.
   LoadBalancingPolicy::UpdateArgs update_args;
-  update_args.addresses.emplace().emplace_back(ring_hash_->endpoints_[index_]);
+  update_args.addresses =
+      std::make_shared<SingleEndpointIterator>(ring_hash_->endpoints_[index_]);
   update_args.args = ring_hash_->args_;
   update_args.config = std::move(*config);
   // TODO(roth): If the child reports a non-OK status with the update,
@@ -622,18 +623,14 @@ absl::Status RingHash::UpdateLocked(UpdateArgs args) {
   // Check address list.
   if (args.addresses.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
-      gpr_log(GPR_INFO, "[RH %p] received update with %" PRIuPTR " addresses",
-              this, args.addresses->size());
+      gpr_log(GPR_INFO, "[RH %p] received update", this);
     }
     // De-dup endpoints, taking weight into account.
     endpoints_.clear();
-    endpoints_.reserve(args.addresses->size());
     std::map<EndpointAddressSet, size_t> endpoint_indices;
-    size_t num_skipped = 0;
-    for (size_t i = 0; i < args.addresses->size(); ++i) {
-      EndpointAddresses& endpoint = (*args.addresses)[i];
+    (*args.addresses)->ForEach([&](const EndpointAddresses& endpoint) {
       const EndpointAddressSet key(endpoint.addresses());
-      auto p = endpoint_indices.emplace(key, i - num_skipped);
+      auto p = endpoint_indices.emplace(key, endpoints_.size());
       if (!p.second) {
         // Duplicate endpoint.  Combine weights and skip the dup.
         EndpointAddresses& prev_endpoint = endpoints_[p.first->second];
@@ -651,11 +648,10 @@ absl::Status RingHash::UpdateLocked(UpdateArgs args) {
             prev_endpoint.addresses(),
             prev_endpoint.args().Set(GRPC_ARG_ADDRESS_WEIGHT,
                                      weight_arg + prev_weight_arg));
-        ++num_skipped;
       } else {
-        endpoints_.push_back(std::move(endpoint));
+        endpoints_.push_back(endpoint);
       }
-    }
+    });
   } else {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_ring_hash_trace)) {
       gpr_log(GPR_INFO, "[RH %p] received update with addresses error: %s",
@@ -681,8 +677,8 @@ absl::Status RingHash::UpdateLocked(UpdateArgs args) {
       it->second->UpdateLocked(i);
       endpoint_map.emplace(address_set, std::move(it->second));
     } else {
-      endpoint_map.emplace(address_set,
-                           MakeOrphanable<RingHashEndpoint>(Ref(), i));
+      endpoint_map.emplace(address_set, MakeOrphanable<RingHashEndpoint>(
+                                            RefAsSubclass<RingHash>(), i));
     }
   }
   endpoint_map_ = std::move(endpoint_map);
@@ -783,7 +779,8 @@ void RingHash::UpdateAggregatedConnectivityStateLocked(
   // Note that we use our own picker regardless of connectivity state.
   channel_control_helper()->UpdateState(
       state, status,
-      MakeRefCounted<Picker>(Ref(DEBUG_LOCATION, "RingHashPicker")));
+      MakeRefCounted<Picker>(
+          RefAsSubclass<RingHash>(DEBUG_LOCATION, "RingHashPicker")));
   // While the ring_hash policy is reporting TRANSIENT_FAILURE, it will
   // not be getting any pick requests from the priority policy.
   // However, because the ring_hash policy does not attempt to