grpc 1.60.0 → 1.62.0

data/src/core/{ext/filters/client_channel/lb_policy → load_balancing}/pick_first/pick_first.cc

@@ -16,12 +16,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy/pick_first/pick_first.h"
+#include "src/core/load_balancing/pick_first/pick_first.h"
 
 #include <inttypes.h>
 #include <string.h>
 
-#include <algorithm>
 #include <memory>
 #include <set>
 #include <string>
@@ -42,7 +41,7 @@
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy/health_check_client.h"
+#include "src/core/load_balancing/health_check_client.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
@@ -61,11 +60,11 @@
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/json/json_args.h"
 #include "src/core/lib/json/json_object_loader.h"
-#include "src/core/lib/load_balancing/lb_policy.h"
-#include "src/core/lib/load_balancing/lb_policy_factory.h"
-#include "src/core/lib/load_balancing/subchannel_interface.h"
-#include "src/core/lib/resolver/endpoint_addresses.h"
 #include "src/core/lib/transport/connectivity_state.h"
+#include "src/core/load_balancing/lb_policy.h"
+#include "src/core/load_balancing/lb_policy_factory.h"
+#include "src/core/load_balancing/subchannel_interface.h"
+#include "src/core/resolver/endpoint_addresses.h"
 
 namespace grpc_core {
 
@@ -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 → load_balancing}/pick_first/pick_first.h

@@ -14,12 +14,12 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_PICK_FIRST_PICK_FIRST_H
-#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_PICK_FIRST_PICK_FIRST_H
+#ifndef GRPC_SRC_CORE_LOAD_BALANCING_PICK_FIRST_PICK_FIRST_H
+#define GRPC_SRC_CORE_LOAD_BALANCING_PICK_FIRST_PICK_FIRST_H
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/resolver/endpoint_addresses.h"
+#include "src/core/resolver/endpoint_addresses.h"
 
 // Internal channel arg to enable health checking in pick_first.
 // Intended to be used by petiole policies (e.g., round_robin) that
@@ -33,4 +33,4 @@
 #define GRPC_ARG_INTERNAL_PICK_FIRST_OMIT_STATUS_MESSAGE_PREFIX \
   GRPC_ARG_NO_SUBCHANNEL_PREFIX "pick_first_omit_status_message_prefix"
 
-#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_PICK_FIRST_PICK_FIRST_H
+#endif  // GRPC_SRC_CORE_LOAD_BALANCING_PICK_FIRST_PICK_FIRST_H

data/src/core/{ext/filters/client_channel/lb_policy → load_balancing}/priority/priority.cc

@@ -39,8 +39,8 @@
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy/address_filtering.h"
-#include "src/core/ext/filters/client_channel/lb_policy/child_policy_handler.h"
+#include "src/core/load_balancing/address_filtering.h"
+#include "src/core/load_balancing/child_policy_handler.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
@@ -56,12 +56,12 @@
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/json/json_args.h"
 #include "src/core/lib/json/json_object_loader.h"
-#include "src/core/lib/load_balancing/delegating_helper.h"
-#include "src/core/lib/load_balancing/lb_policy.h"
-#include "src/core/lib/load_balancing/lb_policy_factory.h"
-#include "src/core/lib/load_balancing/lb_policy_registry.h"
-#include "src/core/lib/resolver/endpoint_addresses.h"
 #include "src/core/lib/transport/connectivity_state.h"
+#include "src/core/load_balancing/delegating_helper.h"
+#include "src/core/load_balancing/lb_policy.h"
+#include "src/core/load_balancing/lb_policy_factory.h"
+#include "src/core/load_balancing/lb_policy_registry.h"
+#include "src/core/resolver/endpoint_addresses.h"
 
 namespace grpc_core {
 
@@ -292,7 +292,7 @@ PriorityLb::PriorityLb(Args args)
     : LoadBalancingPolicy(std::move(args)),
       child_failover_timeout_(std::max(
           Duration::Zero(),
-          args.args
+          channel_args()
               .GetDurationFromIntMillis(GRPC_ARG_PRIORITY_FAILOVER_TIMEOUT_MS)
               .value_or(kDefaultChildFailoverTimeout))) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_priority_trace)) {
@@ -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 → load_balancing}/ring_hash/ring_hash.cc

@@ -16,7 +16,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/lb_policy/ring_hash/ring_hash.h"
+#include "src/core/load_balancing/ring_hash/ring_hash.h"
 
 #include <inttypes.h>
 #include <stdlib.h>
@@ -42,8 +42,8 @@
 #include <grpc/support/json.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/filters/client_channel/client_channel_internal.h"
-#include "src/core/ext/filters/client_channel/lb_policy/pick_first/pick_first.h"
+#include "src/core/client_channel/client_channel_internal.h"
+#include "src/core/load_balancing/pick_first/pick_first.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
@@ -62,12 +62,12 @@
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/json/json.h"
-#include "src/core/lib/load_balancing/delegating_helper.h"
-#include "src/core/lib/load_balancing/lb_policy.h"
-#include "src/core/lib/load_balancing/lb_policy_factory.h"
-#include "src/core/lib/load_balancing/lb_policy_registry.h"
-#include "src/core/lib/resolver/endpoint_addresses.h"
 #include "src/core/lib/transport/connectivity_state.h"
+#include "src/core/load_balancing/delegating_helper.h"
+#include "src/core/load_balancing/lb_policy.h"
+#include "src/core/load_balancing/lb_policy_factory.h"
+#include "src/core/load_balancing/lb_policy_registry.h"
+#include "src/core/resolver/endpoint_addresses.h"
 
 namespace grpc_core {
 
@@ -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

data/src/core/{ext/filters/client_channel/lb_policy → load_balancing}/ring_hash/ring_hash.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_RING_HASH_RING_HASH_H
-#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_RING_HASH_RING_HASH_H
+#ifndef GRPC_SRC_CORE_LOAD_BALANCING_RING_HASH_RING_HASH_H
+#define GRPC_SRC_CORE_LOAD_BALANCING_RING_HASH_RING_HASH_H
 
 #include <grpc/support/port_platform.h>
 
@@ -26,7 +26,7 @@
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/json/json_args.h"
 #include "src/core/lib/json/json_object_loader.h"
-#include "src/core/lib/service_config/service_config_call_data.h"
+#include "src/core/service_config/service_config_call_data.h"
 
 namespace grpc_core {
 
@@ -59,4 +59,4 @@ struct RingHashConfig {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_RING_HASH_RING_HASH_H
+#endif  // GRPC_SRC_CORE_LOAD_BALANCING_RING_HASH_RING_HASH_H