grpc 1.60.2 → 1.61.0.pre2

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

@@ -20,11 +20,13 @@
 
 #include <stddef.h>
 
-#include <algorithm>
 #include <utility>
 
+#include "absl/functional/function_ref.h"
+
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 
 namespace grpc_core {
 
@@ -43,32 +45,63 @@ int HierarchicalPathArg::ChannelArgsCompare(const HierarchicalPathArg* a,
   return 0;
 }
 
+namespace {
+
+class HierarchicalAddressIterator : public EndpointAddressesIterator {
+ public:
+  HierarchicalAddressIterator(
+      std::shared_ptr<EndpointAddressesIterator> parent_it,
+      RefCountedStringValue child_name)
+      : parent_it_(std::move(parent_it)), child_name_(std::move(child_name)) {}
+
+  void ForEach(absl::FunctionRef<void(const EndpointAddresses&)> callback)
+      const override {
+    RefCountedPtr<HierarchicalPathArg> remaining_path_attr;
+    parent_it_->ForEach([&](const EndpointAddresses& endpoint) {
+      const auto* path_arg = endpoint.args().GetObject<HierarchicalPathArg>();
+      if (path_arg == nullptr) return;
+      const std::vector<RefCountedStringValue>& path = path_arg->path();
+      auto it = path.begin();
+      if (it == path.end()) return;
+      if (*it != child_name_) return;
+      ChannelArgs args = endpoint.args();
+      ++it;
+      if (it != path.end()) {
+        std::vector<RefCountedStringValue> remaining_path(it, path.end());
+        if (remaining_path_attr == nullptr ||
+            remaining_path_attr->path() != remaining_path) {
+          remaining_path_attr =
+              MakeRefCounted<HierarchicalPathArg>(std::move(remaining_path));
+        }
+        args = args.SetObject(remaining_path_attr);
+      }
+      callback(EndpointAddresses(endpoint.addresses(), args));
+    });
+  }
+
+ private:
+  std::shared_ptr<EndpointAddressesIterator> parent_it_;
+  RefCountedStringValue child_name_;
+};
+
+}  // namespace
+
 absl::StatusOr<HierarchicalAddressMap> MakeHierarchicalAddressMap(
-    const absl::StatusOr<EndpointAddressesList>& addresses) {
+    absl::StatusOr<std::shared_ptr<EndpointAddressesIterator>> addresses) {
   if (!addresses.ok()) return addresses.status();
   HierarchicalAddressMap result;
-  RefCountedPtr<HierarchicalPathArg> remaining_path_attr;
-  for (const EndpointAddresses& endpoint_addresses : *addresses) {
-    const auto* path_arg =
-        endpoint_addresses.args().GetObject<HierarchicalPathArg>();
-    if (path_arg == nullptr) continue;
+  (*addresses)->ForEach([&](const EndpointAddresses& endpoint) {
+    const auto* path_arg = endpoint.args().GetObject<HierarchicalPathArg>();
+    if (path_arg == nullptr) return;
     const std::vector<RefCountedStringValue>& path = path_arg->path();
     auto it = path.begin();
-    if (it == path.end()) continue;
-    EndpointAddressesList& target_list = result[*it];
-    ChannelArgs args = endpoint_addresses.args();
-    ++it;
-    if (it != path.end()) {
-      std::vector<RefCountedStringValue> remaining_path(it, path.end());
-      if (remaining_path_attr == nullptr ||
-          remaining_path_attr->path() != remaining_path) {
-        remaining_path_attr =
-            MakeRefCounted<HierarchicalPathArg>(std::move(remaining_path));
-      }
-      args = args.SetObject(remaining_path_attr);
+    if (it == path.end()) return;
+    auto& target_list = result[*it];
+    if (target_list == nullptr) {
+      target_list =
+          std::make_shared<HierarchicalAddressIterator>(*addresses, *it);
     }
-    target_list.emplace_back(endpoint_addresses.addresses(), args);
-  }
+  });
   return result;
 }
 

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

@@ -20,6 +20,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <map>
+#include <memory>
 #include <utility>
 #include <vector>
 
@@ -105,12 +106,12 @@ class HierarchicalPathArg : public RefCounted<HierarchicalPathArg> {
 // A map from the next path element to the endpoint addresses that fall
 // under that path element.
 using HierarchicalAddressMap =
-    std::map<RefCountedStringValue, EndpointAddressesList,
+    std::map<RefCountedStringValue, std::shared_ptr<EndpointAddressesIterator>,
              RefCountedStringValueLessThan>;
 
 // Splits up the addresses into a separate list for each child.
 absl::StatusOr<HierarchicalAddressMap> MakeHierarchicalAddressMap(
-    const absl::StatusOr<EndpointAddressesList>& addresses);
+    absl::StatusOr<std::shared_ptr<EndpointAddressesIterator>> addresses);
 
 }  // namespace grpc_core
 

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

@@ -272,7 +272,8 @@ void ChildPolicyHandler::ResetBackoffLocked() {
 
 OrphanablePtr<LoadBalancingPolicy> ChildPolicyHandler::CreateChildPolicy(
     absl::string_view child_policy_name, const ChannelArgs& args) {
-  Helper* helper = new Helper(Ref(DEBUG_LOCATION, "Helper"));
+  Helper* helper =
+      new Helper(RefAsSubclass<ChildPolicyHandler>(DEBUG_LOCATION, "Helper"));
   LoadBalancingPolicy::Args lb_policy_args;
   lb_policy_args.work_serializer = work_serializer();
   lb_policy_args.channel_control_helper =

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

@@ -69,6 +69,9 @@ class EndpointList::Endpoint::Helper
       grpc_connectivity_state state, const absl::Status& status,
       RefCountedPtr<LoadBalancingPolicy::SubchannelPicker> picker) override {
     auto old_state = std::exchange(endpoint_->connectivity_state_, state);
+    if (!old_state.has_value()) {
+      ++endpoint_->endpoint_list_->num_endpoints_seen_initial_state_;
+    }
     endpoint_->picker_ = std::move(picker);
     endpoint_->OnStateUpdate(old_state, state, status);
   }
@@ -118,7 +121,7 @@ void EndpointList::Endpoint::Init(
   GPR_ASSERT(config.ok());
   // Update child policy.
   LoadBalancingPolicy::UpdateArgs update_args;
-  update_args.addresses.emplace().emplace_back(addresses);
+  update_args.addresses = std::make_shared<SingleEndpointIterator>(addresses);
   update_args.args = child_args;
   update_args.config = std::move(*config);
   // TODO(roth): If the child reports a non-OK status with the update,
@@ -163,15 +166,16 @@ RefCountedPtr<SubchannelInterface> EndpointList::Endpoint::CreateSubchannel(
 //
 
 void EndpointList::Init(
-    const EndpointAddressesList& endpoints, const ChannelArgs& args,
-    absl::AnyInvocable<OrphanablePtr<Endpoint>(RefCountedPtr<EndpointList>,
-                                               const EndpointAddresses&,
-                                               const ChannelArgs&)>
+    EndpointAddressesIterator* endpoints, const ChannelArgs& args,
+    absl::FunctionRef<OrphanablePtr<Endpoint>(RefCountedPtr<EndpointList>,
+                                              const EndpointAddresses&,
+                                              const ChannelArgs&)>
         create_endpoint) {
-  for (const EndpointAddresses& addresses : endpoints) {
+  if (endpoints == nullptr) return;
+  endpoints->ForEach([&](const EndpointAddresses& endpoint) {
     endpoints_.push_back(
-        create_endpoint(Ref(DEBUG_LOCATION, "Endpoint"), addresses, args));
-  }
+        create_endpoint(Ref(DEBUG_LOCATION, "Endpoint"), endpoint, args));
+  });
 }
 
 void EndpointList::ResetBackoffLocked() {
@@ -180,11 +184,4 @@ void EndpointList::ResetBackoffLocked() {
   }
 }
 
-bool EndpointList::AllEndpointsSeenInitialState() const {
-  for (const auto& endpoint : endpoints_) {
-    if (!endpoint->connectivity_state().has_value()) return false;
-  }
-  return true;
-}
-
 }  // namespace grpc_core

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

@@ -25,7 +25,7 @@
 #include <utility>
 #include <vector>
 
-#include "absl/functional/any_invocable.h"
+#include "absl/functional/function_ref.h"
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
 
@@ -53,7 +53,7 @@ namespace grpc_core {
 class MyEndpointList : public EndpointList {
  public:
   MyEndpointList(RefCountedPtr<MyLbPolicy> lb_policy,
-                 const EndpointAddressesList& endpoints,
+                 EndpointAddressesIterator* endpoints,
                  const ChannelArgs& args)
       : EndpointList(std::move(lb_policy),
                      GRPC_TRACE_FLAG_ENABLED(grpc_my_tracer)
@@ -184,8 +184,8 @@ class EndpointList : public InternallyRefCounted<EndpointList> {
   EndpointList(RefCountedPtr<LoadBalancingPolicy> policy, const char* tracer)
       : policy_(std::move(policy)), tracer_(tracer) {}
 
-  void Init(const EndpointAddressesList& endpoints, const ChannelArgs& args,
-            absl::AnyInvocable<OrphanablePtr<Endpoint>(
+  void Init(EndpointAddressesIterator* endpoints, const ChannelArgs& args,
+            absl::FunctionRef<OrphanablePtr<Endpoint>(
                 RefCountedPtr<EndpointList>, const EndpointAddresses&,
                 const ChannelArgs&)>
                 create_endpoint);
@@ -199,7 +199,9 @@ class EndpointList : public InternallyRefCounted<EndpointList> {
 
   // Returns true if all endpoints have seen their initial connectivity
   // state notification.
-  bool AllEndpointsSeenInitialState() const;
+  bool AllEndpointsSeenInitialState() const {
+    return num_endpoints_seen_initial_state_ == size();
+  }
 
  private:
   // Returns the parent policy's helper.  Needed because the accessor
@@ -210,6 +212,7 @@ class EndpointList : public InternallyRefCounted<EndpointList> {
   RefCountedPtr<LoadBalancingPolicy> policy_;
   const char* tracer_;
   std::vector<OrphanablePtr<Endpoint>> endpoints_;
+  size_t num_endpoints_seen_initial_state_ = 0;
 };
 
 }  // namespace grpc_core

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

@@ -72,6 +72,7 @@
 #include <vector>
 
 #include "absl/container/inlined_vector.h"
+#include "absl/functional/function_ref.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
@@ -80,7 +81,7 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "absl/types/variant.h"
-#include "upb/upb.hpp"
+#include "upb/mem/arena.hpp"
 
 #include <grpc/byte_buffer.h>
 #include <grpc/byte_buffer_reader.h>
@@ -323,9 +324,8 @@ class GrpcLb : public LoadBalancingPolicy {
         }
         return;
       }
-      WeakRefCountedPtr<SubchannelWrapper> self = WeakRef();
       lb_policy_->work_serializer()->Run(
-          [self = std::move(self)]() {
+          [self = WeakRefAsSubclass<SubchannelWrapper>()]() {
             if (!self->lb_policy_->shutting_down_) {
               self->lb_policy_->CacheDeletedSubchannelLocked(
                   self->wrapped_subchannel());
@@ -384,9 +384,9 @@ class GrpcLb : public LoadBalancingPolicy {
     // Returns a text representation suitable for logging.
     std::string AsText() const;
 
-    // Extracts all non-drop entries into an EndpointAddressesList.
-    EndpointAddressesList GetServerAddressList(
-        GrpcLbClientStats* client_stats) const;
+    // Extracts all non-drop entries into an EndpointAddressesIterator.
+    std::shared_ptr<EndpointAddressesIterator> GetServerAddressList(
+        GrpcLbClientStats* client_stats);
 
     // Returns true if the serverlist contains at least one drop entry and
     // no backend address entries.
@@ -400,6 +400,8 @@ class GrpcLb : public LoadBalancingPolicy {
     const char* ShouldDrop();
 
    private:
+    class AddressIterator;
+
     std::vector<GrpcLbServer> serverlist_;
 
     // Accessed from the picker, so needs synchronization.
@@ -504,6 +506,8 @@ class GrpcLb : public LoadBalancingPolicy {
     RefCountedPtr<GrpcLb> parent_;
   };
 
+  class NullLbTokenEndpointIterator;
+
   void ShutdownLocked() override;
 
   // Helper functions used in UpdateLocked().
@@ -569,7 +573,8 @@ class GrpcLb : public LoadBalancingPolicy {
   // Whether we're in fallback mode.
   bool fallback_mode_ = false;
   // The backend addresses from the resolver.
-  absl::StatusOr<EndpointAddressesList> fallback_backend_addresses_;
+  absl::StatusOr<std::shared_ptr<NullLbTokenEndpointIterator>>
+      fallback_backend_addresses_;
   // The last resolution note from our parent.
   // To be passed to child policy when fallback_backend_addresses_ is empty.
   std::string resolution_note_;
@@ -594,11 +599,30 @@ class GrpcLb : public LoadBalancingPolicy {
 };
 
 //
-// GrpcLb::Serverlist
+// GrpcLb::Serverlist::AddressIterator
 //
 
-bool GrpcLb::Serverlist::operator==(const Serverlist& other) const {
-  return serverlist_ == other.serverlist_;
+bool IsServerValid(const GrpcLbServer& server, size_t idx, bool log) {
+  if (server.drop) return false;
+  if (GPR_UNLIKELY(server.port >> 16 != 0)) {
+    if (log) {
+      gpr_log(GPR_ERROR,
+              "Invalid port '%d' at index %" PRIuPTR
+              " of serverlist. Ignoring.",
+              server.port, idx);
+    }
+    return false;
+  }
+  if (GPR_UNLIKELY(server.ip_size != 4 && server.ip_size != 16)) {
+    if (log) {
+      gpr_log(GPR_ERROR,
+              "Expected IP to be 4 or 16 bytes, got %d at index %" PRIuPTR
+              " of serverlist. Ignoring",
+              server.ip_size, idx);
+    }
+    return false;
+  }
+  return true;
 }
 
 void ParseServer(const GrpcLbServer& server, grpc_resolved_address* addr) {
@@ -623,6 +647,53 @@ void ParseServer(const GrpcLbServer& server, grpc_resolved_address* addr) {
   }
 }
 
+class GrpcLb::Serverlist::AddressIterator : public EndpointAddressesIterator {
+ public:
+  AddressIterator(RefCountedPtr<Serverlist> serverlist,
+                  RefCountedPtr<GrpcLbClientStats> client_stats)
+      : serverlist_(std::move(serverlist)),
+        client_stats_(std::move(client_stats)) {}
+
+  void ForEach(absl::FunctionRef<void(const EndpointAddresses&)> callback)
+      const override {
+    for (size_t i = 0; i < serverlist_->serverlist_.size(); ++i) {
+      const GrpcLbServer& server = serverlist_->serverlist_[i];
+      if (!IsServerValid(server, i, false)) continue;
+      // Address processing.
+      grpc_resolved_address addr;
+      ParseServer(server, &addr);
+      // LB token processing.
+      const size_t lb_token_length = strnlen(
+          server.load_balance_token, GPR_ARRAY_SIZE(server.load_balance_token));
+      std::string lb_token(server.load_balance_token, lb_token_length);
+      if (lb_token.empty()) {
+        auto addr_uri = grpc_sockaddr_to_uri(&addr);
+        gpr_log(GPR_INFO,
+                "Missing LB token for backend address '%s'. The empty token "
+                "will be used instead",
+                addr_uri.ok() ? addr_uri->c_str()
+                              : addr_uri.status().ToString().c_str());
+      }
+      // Return address with a channel arg containing LB token and stats object.
+      callback(EndpointAddresses(
+          addr, ChannelArgs().SetObject(MakeRefCounted<TokenAndClientStatsArg>(
+                    std::move(lb_token), client_stats_))));
+    }
+  }
+
+ private:
+  RefCountedPtr<Serverlist> serverlist_;
+  RefCountedPtr<GrpcLbClientStats> client_stats_;
+};
+
+//
+// GrpcLb::Serverlist
+//
+
+bool GrpcLb::Serverlist::operator==(const Serverlist& other) const {
+  return serverlist_ == other.serverlist_;
+}
+
 std::string GrpcLb::Serverlist::AsText() const {
   std::vector<std::string> entries;
   for (size_t i = 0; i < serverlist_.size(); ++i) {
@@ -642,59 +713,12 @@ std::string GrpcLb::Serverlist::AsText() const {
   return absl::StrJoin(entries, "");
 }
 
-bool IsServerValid(const GrpcLbServer& server, size_t idx, bool log) {
-  if (server.drop) return false;
-  if (GPR_UNLIKELY(server.port >> 16 != 0)) {
-    if (log) {
-      gpr_log(GPR_ERROR,
-              "Invalid port '%d' at index %" PRIuPTR
-              " of serverlist. Ignoring.",
-              server.port, idx);
-    }
-    return false;
-  }
-  if (GPR_UNLIKELY(server.ip_size != 4 && server.ip_size != 16)) {
-    if (log) {
-      gpr_log(GPR_ERROR,
-              "Expected IP to be 4 or 16 bytes, got %d at index %" PRIuPTR
-              " of serverlist. Ignoring",
-              server.ip_size, idx);
-    }
-    return false;
-  }
-  return true;
-}
-
 // Returns addresses extracted from the serverlist.
-EndpointAddressesList GrpcLb::Serverlist::GetServerAddressList(
-    GrpcLbClientStats* client_stats) const {
+std::shared_ptr<EndpointAddressesIterator>
+GrpcLb::Serverlist::GetServerAddressList(GrpcLbClientStats* client_stats) {
   RefCountedPtr<GrpcLbClientStats> stats;
   if (client_stats != nullptr) stats = client_stats->Ref();
-  EndpointAddressesList endpoints;
-  for (size_t i = 0; i < serverlist_.size(); ++i) {
-    const GrpcLbServer& server = serverlist_[i];
-    if (!IsServerValid(server, i, false)) continue;
-    // Address processing.
-    grpc_resolved_address addr;
-    ParseServer(server, &addr);
-    // LB token processing.
-    const size_t lb_token_length = strnlen(
-        server.load_balance_token, GPR_ARRAY_SIZE(server.load_balance_token));
-    std::string lb_token(server.load_balance_token, lb_token_length);
-    if (lb_token.empty()) {
-      auto addr_uri = grpc_sockaddr_to_uri(&addr);
-      gpr_log(GPR_INFO,
-              "Missing LB token for backend address '%s'. The empty token will "
-              "be used instead",
-              addr_uri.ok() ? addr_uri->c_str()
-                            : addr_uri.status().ToString().c_str());
-    }
-    // Add address with a channel arg containing LB token and stats object.
-    endpoints.emplace_back(
-        addr, ChannelArgs().SetObject(MakeRefCounted<TokenAndClientStatsArg>(
-                  std::move(lb_token), stats)));
-  }
-  return endpoints;
+  return std::make_shared<AddressIterator>(Ref(), std::move(stats));
 }
 
 bool GrpcLb::Serverlist::ContainsAllDropEntries() const {
@@ -794,8 +818,8 @@ RefCountedPtr<SubchannelInterface> GrpcLb::Helper::CreateSubchannel(
   return MakeRefCounted<SubchannelWrapper>(
       parent()->channel_control_helper()->CreateSubchannel(
           address, per_address_args, args),
-      parent()->Ref(DEBUG_LOCATION, "SubchannelWrapper"), std::move(lb_token),
-      std::move(client_stats));
+      parent()->RefAsSubclass<GrpcLb>(DEBUG_LOCATION, "SubchannelWrapper"),
+      std::move(lb_token), std::move(client_stats));
 }
 
 void GrpcLb::Helper::UpdateState(grpc_connectivity_state state,
@@ -1503,28 +1527,45 @@ void GrpcLb::ResetBackoffLocked() {
   }
 }
 
+// Endpoint iterator wrapper to add null LB token attribute.
+class GrpcLb::NullLbTokenEndpointIterator : public EndpointAddressesIterator {
+ public:
+  explicit NullLbTokenEndpointIterator(
+      std::shared_ptr<EndpointAddressesIterator> parent_it)
+      : parent_it_(std::move(parent_it)) {}
+
+  void ForEach(absl::FunctionRef<void(const EndpointAddresses&)> callback)
+      const override {
+    parent_it_->ForEach([&](const EndpointAddresses& endpoint) {
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_glb_trace)) {
+        gpr_log(GPR_INFO, "[grpclb %p] fallback address: %s", this,
+                endpoint.ToString().c_str());
+      }
+      callback(EndpointAddresses(endpoint.addresses(),
+                                 endpoint.args().SetObject(empty_token_)));
+    });
+  }
+
+ private:
+  std::shared_ptr<EndpointAddressesIterator> parent_it_;
+  RefCountedPtr<TokenAndClientStatsArg> empty_token_ =
+      MakeRefCounted<TokenAndClientStatsArg>("", nullptr);
+};
+
 absl::Status GrpcLb::UpdateLocked(UpdateArgs args) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_glb_trace)) {
     gpr_log(GPR_INFO, "[grpclb %p] received update", this);
   }
   const bool is_initial_update = lb_channel_ == nullptr;
-  config_ = args.config;
+  config_ = args.config.TakeAsSubclass<GrpcLbConfig>();
   GPR_ASSERT(config_ != nullptr);
   args_ = std::move(args.args);
   // Update fallback address list.
-  fallback_backend_addresses_ = std::move(args.addresses);
-  if (fallback_backend_addresses_.ok()) {
-    // Add null LB token attributes.
-    for (EndpointAddresses& endpoint : *fallback_backend_addresses_) {
-      endpoint = EndpointAddresses(
-          endpoint.addresses(),
-          endpoint.args().SetObject(
-              MakeRefCounted<TokenAndClientStatsArg>("", nullptr)));
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_glb_trace)) {
-        gpr_log(GPR_INFO, "[grpclb %p] fallback address: %s", this,
-                endpoint.ToString().c_str());
-      }
-    }
+  if (!args.addresses.ok()) {
+    fallback_backend_addresses_ = args.addresses.status();
+  } else {
+    fallback_backend_addresses_ = std::make_shared<NullLbTokenEndpointIterator>(
+        std::move(*args.addresses));
   }
   resolution_note_ = std::move(args.resolution_note);
   // Update balancer channel.
@@ -1539,8 +1580,8 @@ absl::Status GrpcLb::UpdateLocked(UpdateArgs args) {
     lb_fallback_timer_handle_ =
         channel_control_helper()->GetEventEngine()->RunAfter(
             fallback_at_startup_timeout_,
-            [self = static_cast<RefCountedPtr<GrpcLb>>(
-                 Ref(DEBUG_LOCATION, "on_fallback_timer"))]() mutable {
+            [self = RefAsSubclass<GrpcLb>(DEBUG_LOCATION,
+                                          "on_fallback_timer")]() mutable {
               ApplicationCallbackExecCtx callback_exec_ctx;
               ExecCtx exec_ctx;
               auto self_ptr = self.get();
@@ -1555,7 +1596,8 @@ absl::Status GrpcLb::UpdateLocked(UpdateArgs args) {
         ClientChannel::GetFromChannel(Channel::FromC(lb_channel_));
     GPR_ASSERT(client_channel != nullptr);
     // Ref held by callback.
-    watcher_ = new StateWatcher(Ref(DEBUG_LOCATION, "StateWatcher"));
+    watcher_ =
+        new StateWatcher(RefAsSubclass<GrpcLb>(DEBUG_LOCATION, "StateWatcher"));
     client_channel->AddConnectivityWatcher(
         GRPC_CHANNEL_IDLE,
         OrphanablePtr<AsyncConnectivityStateWatcherInterface>(watcher_));
@@ -1598,11 +1640,10 @@ absl::Status GrpcLb::UpdateBalancerChannelLocked() {
     // Set up channelz linkage.
     channelz::ChannelNode* child_channelz_node =
         grpc_channel_get_channelz_node(lb_channel_);
-    channelz::ChannelNode* parent_channelz_node =
-        args_.GetObject<channelz::ChannelNode>();
+    auto parent_channelz_node = 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);
     }
   }
   // Propagate updates to the LB channel (pick_first) through the fake
@@ -1657,8 +1698,8 @@ void GrpcLb::StartBalancerCallRetryTimerLocked() {
   lb_call_retry_timer_handle_ =
       channel_control_helper()->GetEventEngine()->RunAfter(
           timeout,
-          [self = static_cast<RefCountedPtr<GrpcLb>>(
-               Ref(DEBUG_LOCATION, "on_balancer_call_retry_timer"))]() mutable {
+          [self = RefAsSubclass<GrpcLb>(
+               DEBUG_LOCATION, "on_balancer_call_retry_timer")]() mutable {
             ApplicationCallbackExecCtx callback_exec_ctx;
             ExecCtx exec_ctx;
             auto self_ptr = self.get();
@@ -1740,7 +1781,7 @@ OrphanablePtr<LoadBalancingPolicy> GrpcLb::CreateChildPolicyLocked(
   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"));
+      std::make_unique<Helper>(RefAsSubclass<GrpcLb>(DEBUG_LOCATION, "Helper"));
   OrphanablePtr<LoadBalancingPolicy> lb_policy =
       MakeOrphanable<ChildPolicyHandler>(std::move(lb_policy_args),
                                          &grpc_lb_glb_trace);
@@ -1756,6 +1797,12 @@ OrphanablePtr<LoadBalancingPolicy> GrpcLb::CreateChildPolicyLocked(
   return lb_policy;
 }
 
+bool EndpointIteratorIsEmpty(const EndpointAddressesIterator& endpoints) {
+  bool empty = true;
+  endpoints.ForEach([&](const EndpointAddresses&) { empty = false; });
+  return empty;
+}
+
 void GrpcLb::CreateOrUpdateChildPolicyLocked() {
   if (shutting_down_) return;
   // Construct update args.
@@ -1769,16 +1816,17 @@ void GrpcLb::CreateOrUpdateChildPolicyLocked() {
     // picks.
     update_args.addresses = fallback_backend_addresses_;
     if (fallback_backend_addresses_.ok() &&
-        fallback_backend_addresses_->empty()) {
+        EndpointIteratorIsEmpty(**fallback_backend_addresses_)) {
       update_args.resolution_note = absl::StrCat(
-          "grpclb in fallback mode without any balancer addresses: ",
+          "grpclb in fallback mode without any fallback addresses: ",
           resolution_note_);
     }
   } else {
     update_args.addresses = serverlist_->GetServerAddressList(
         lb_calld_ == nullptr ? nullptr : lb_calld_->client_stats());
     is_backend_from_grpclb_load_balancer = true;
-    if (update_args.addresses.ok() && update_args.addresses->empty()) {
+    if (update_args.addresses.ok() &&
+        EndpointIteratorIsEmpty(**update_args.addresses)) {
       update_args.resolution_note = "empty serverlist from grpclb balancer";
     }
   }
@@ -1818,8 +1866,8 @@ void GrpcLb::StartSubchannelCacheTimerLocked() {
   subchannel_cache_timer_handle_ =
       channel_control_helper()->GetEventEngine()->RunAfter(
           cached_subchannels_.begin()->first - Timestamp::Now(),
-          [self = static_cast<RefCountedPtr<GrpcLb>>(
-               Ref(DEBUG_LOCATION, "OnSubchannelCacheTimer"))]() mutable {
+          [self = RefAsSubclass<GrpcLb>(DEBUG_LOCATION,
+                                        "OnSubchannelCacheTimer")]() mutable {
             ApplicationCallbackExecCtx callback_exec_ctx;
             ExecCtx exec_ctx;
             auto* self_ptr = self.get();
@@ -1880,8 +1928,7 @@ void RegisterGrpcLbPolicy(CoreConfiguration::Builder* builder) {
   builder->lb_policy_registry()->RegisterLoadBalancingPolicyFactory(
       std::make_unique<GrpcLbFactory>());
   builder->channel_init()
-      ->RegisterFilter(GRPC_CLIENT_SUBCHANNEL,
-                       &ClientLoadReportingFilter::kFilter)
+      ->RegisterFilter<ClientLoadReportingFilter>(GRPC_CLIENT_SUBCHANNEL)
       .IfChannelArg(GRPC_ARG_GRPCLB_ENABLE_LOAD_REPORTING_FILTER, false);
 }
 

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

@@ -32,7 +32,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/impl/channel_arg_names.h>
 #include <grpc/impl/connectivity_state.h>
@@ -356,7 +356,8 @@ void HealthProducer::Start(RefCountedPtr<Subchannel> subchannel) {
     MutexLock lock(&mu_);
     connected_subchannel_ = subchannel_->connected_subchannel();
   }
-  auto connectivity_watcher = MakeRefCounted<ConnectivityWatcher>(WeakRef());
+  auto connectivity_watcher =
+      MakeRefCounted<ConnectivityWatcher>(WeakRefAsSubclass<HealthProducer>());
   connectivity_watcher_ = connectivity_watcher.get();
   subchannel_->WatchConnectivityState(std::move(connectivity_watcher));
 }
@@ -387,7 +388,8 @@ void HealthProducer::AddWatcher(
         health_checkers_.emplace(*health_check_service_name, nullptr).first;
     auto& health_checker = it->second;
     if (health_checker == nullptr) {
-      health_checker = MakeOrphanable<HealthChecker>(WeakRef(), it->first);
+      health_checker = MakeOrphanable<HealthChecker>(
+          WeakRefAsSubclass<HealthProducer>(), it->first);
     }
     health_checker->AddWatcherLocked(watcher);
   }
@@ -456,7 +458,10 @@ void HealthWatcher::SetSubchannel(Subchannel* subchannel) {
   subchannel->GetOrAddDataProducer(
       HealthProducer::Type(),
       [&](Subchannel::DataProducerInterface** producer) {
-        if (*producer != nullptr) producer_ = (*producer)->RefIfNonZero();
+        if (*producer != nullptr) {
+          producer_ =
+              (*producer)->RefIfNonZero().TakeAsSubclass<HealthProducer>();
+        }
         if (producer_ == nullptr) {
           producer_ = MakeRefCounted<HealthProducer>();
           *producer = producer_.get();