grpc 1.58.0 → 1.59.0

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

@@ -37,10 +37,12 @@
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/support/log.h>
 
+#include "src/core/ext/filters/client_channel/lb_policy/endpoint_list.h"
 #include "src/core/ext/filters/client_channel/lb_policy/subchannel_list.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -59,14 +61,14 @@ TraceFlag grpc_lb_round_robin_trace(false, "round_robin");
 namespace {
 
 //
-// round_robin LB policy
+// legacy round_robin LB policy (before dualstack support)
 //
 
 constexpr absl::string_view kRoundRobin = "round_robin";
 
-class RoundRobin : public LoadBalancingPolicy {
+class OldRoundRobin : public LoadBalancingPolicy {
  public:
-  explicit RoundRobin(Args args);
+  explicit OldRoundRobin(Args args);
 
   absl::string_view name() const override { return kRoundRobin; }
 
@@ -74,7 +76,7 @@ class RoundRobin : public LoadBalancingPolicy {
   void ResetBackoffLocked() override;
 
  private:
-  ~RoundRobin() override;
+  ~OldRoundRobin() override;
 
   // Forward declaration.
   class RoundRobinSubchannelList;
@@ -122,7 +124,7 @@ class RoundRobin : public LoadBalancingPolicy {
       : public SubchannelList<RoundRobinSubchannelList,
                               RoundRobinSubchannelData> {
    public:
-    RoundRobinSubchannelList(RoundRobin* policy, ServerAddressList addresses,
+    RoundRobinSubchannelList(OldRoundRobin* policy, ServerAddressList addresses,
                              const ChannelArgs& args)
         : SubchannelList(policy,
                          (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)
@@ -137,7 +139,7 @@ class RoundRobin : public LoadBalancingPolicy {
     }
 
     ~RoundRobinSubchannelList() override {
-      RoundRobin* p = static_cast<RoundRobin*>(policy());
+      OldRoundRobin* p = static_cast<OldRoundRobin*>(policy());
       p->Unref(DEBUG_LOCATION, "subchannel_list");
     }
 
@@ -155,7 +157,7 @@ class RoundRobin : public LoadBalancingPolicy {
 
    private:
     std::shared_ptr<WorkSerializer> work_serializer() const override {
-      return static_cast<RoundRobin*>(policy())->work_serializer();
+      return static_cast<OldRoundRobin*>(policy())->work_serializer();
     }
 
     std::string CountersString() const {
@@ -174,13 +176,13 @@ class RoundRobin : public LoadBalancingPolicy {
 
   class Picker : public SubchannelPicker {
    public:
-    Picker(RoundRobin* parent, RoundRobinSubchannelList* subchannel_list);
+    Picker(OldRoundRobin* parent, RoundRobinSubchannelList* subchannel_list);
 
     PickResult Pick(PickArgs args) override;
 
    private:
     // Using pointer value only, no ref held -- do not dereference!
-    RoundRobin* parent_;
+    OldRoundRobin* parent_;
 
     std::atomic<size_t> last_picked_index_;
     std::vector<RefCountedPtr<SubchannelInterface>> subchannels_;
@@ -202,11 +204,11 @@ class RoundRobin : public LoadBalancingPolicy {
 };
 
 //
-// RoundRobin::Picker
+// OldRoundRobin::Picker
 //
 
-RoundRobin::Picker::Picker(RoundRobin* parent,
-                           RoundRobinSubchannelList* subchannel_list)
+OldRoundRobin::Picker::Picker(OldRoundRobin* parent,
+                              RoundRobinSubchannelList* subchannel_list)
     : parent_(parent) {
   for (size_t i = 0; i < subchannel_list->num_subchannels(); ++i) {
     RoundRobinSubchannelData* sd = subchannel_list->subchannel(i);
@@ -228,7 +230,7 @@ RoundRobin::Picker::Picker(RoundRobin* parent,
   }
 }
 
-RoundRobin::PickResult RoundRobin::Picker::Pick(PickArgs /*args*/) {
+OldRoundRobin::PickResult OldRoundRobin::Picker::Pick(PickArgs /*args*/) {
   size_t index = last_picked_index_.fetch_add(1, std::memory_order_relaxed) %
                  subchannels_.size();
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
@@ -243,13 +245,13 @@ RoundRobin::PickResult RoundRobin::Picker::Pick(PickArgs /*args*/) {
 // RoundRobin
 //
 
-RoundRobin::RoundRobin(Args args) : LoadBalancingPolicy(std::move(args)) {
+OldRoundRobin::OldRoundRobin(Args args) : LoadBalancingPolicy(std::move(args)) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
     gpr_log(GPR_INFO, "[RR %p] Created", this);
   }
 }
 
-RoundRobin::~RoundRobin() {
+OldRoundRobin::~OldRoundRobin() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
     gpr_log(GPR_INFO, "[RR %p] Destroying Round Robin policy", this);
   }
@@ -257,7 +259,7 @@ RoundRobin::~RoundRobin() {
   GPR_ASSERT(latest_pending_subchannel_list_ == nullptr);
 }
 
-void RoundRobin::ShutdownLocked() {
+void OldRoundRobin::ShutdownLocked() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
     gpr_log(GPR_INFO, "[RR %p] Shutting down", this);
   }
@@ -266,14 +268,14 @@ void RoundRobin::ShutdownLocked() {
   latest_pending_subchannel_list_.reset();
 }
 
-void RoundRobin::ResetBackoffLocked() {
+void OldRoundRobin::ResetBackoffLocked() {
   subchannel_list_->ResetBackoffLocked();
   if (latest_pending_subchannel_list_ != nullptr) {
     latest_pending_subchannel_list_->ResetBackoffLocked();
   }
 }
 
-absl::Status RoundRobin::UpdateLocked(UpdateArgs args) {
+absl::Status OldRoundRobin::UpdateLocked(UpdateArgs args) {
   ServerAddressList addresses;
   if (args.addresses.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
@@ -329,7 +331,7 @@ absl::Status RoundRobin::UpdateLocked(UpdateArgs args) {
 // RoundRobinSubchannelList
 //
 
-void RoundRobin::RoundRobinSubchannelList::UpdateStateCountersLocked(
+void OldRoundRobin::RoundRobinSubchannelList::UpdateStateCountersLocked(
     absl::optional<grpc_connectivity_state> old_state,
     grpc_connectivity_state new_state) {
   if (old_state.has_value()) {
@@ -355,9 +357,9 @@ void RoundRobin::RoundRobinSubchannelList::UpdateStateCountersLocked(
   }
 }
 
-void RoundRobin::RoundRobinSubchannelList::
+void OldRoundRobin::RoundRobinSubchannelList::
     MaybeUpdateRoundRobinConnectivityStateLocked(absl::Status status_for_tf) {
-  RoundRobin* p = static_cast<RoundRobin*>(policy());
+  OldRoundRobin* p = static_cast<OldRoundRobin*>(policy());
   // If this is latest_pending_subchannel_list_, then swap it into
   // subchannel_list_ in the following cases:
   // - subchannel_list_ has no READY subchannels.
@@ -424,10 +426,10 @@ void RoundRobin::RoundRobinSubchannelList::
 // RoundRobinSubchannelData
 //
 
-void RoundRobin::RoundRobinSubchannelData::ProcessConnectivityChangeLocked(
+void OldRoundRobin::RoundRobinSubchannelData::ProcessConnectivityChangeLocked(
     absl::optional<grpc_connectivity_state> old_state,
     grpc_connectivity_state new_state) {
-  RoundRobin* p = static_cast<RoundRobin*>(subchannel_list()->policy());
+  OldRoundRobin* p = static_cast<OldRoundRobin*>(subchannel_list()->policy());
   GPR_ASSERT(subchannel() != nullptr);
   // If this is not the initial state notification and the new state is
   // TRANSIENT_FAILURE or IDLE, re-resolve.
@@ -457,9 +459,10 @@ void RoundRobin::RoundRobinSubchannelData::ProcessConnectivityChangeLocked(
       connectivity_status());
 }
 
-void RoundRobin::RoundRobinSubchannelData::UpdateLogicalConnectivityStateLocked(
-    grpc_connectivity_state connectivity_state) {
-  RoundRobin* p = static_cast<RoundRobin*>(subchannel_list()->policy());
+void OldRoundRobin::RoundRobinSubchannelData::
+    UpdateLogicalConnectivityStateLocked(
+        grpc_connectivity_state connectivity_state) {
+  OldRoundRobin* p = static_cast<OldRoundRobin*>(subchannel_list()->policy());
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
     gpr_log(
         GPR_INFO,
@@ -503,6 +506,384 @@ void RoundRobin::RoundRobinSubchannelData::UpdateLogicalConnectivityStateLocked(
   logical_connectivity_state_ = connectivity_state;
 }
 
+//
+// round_robin LB policy (with dualstack changes)
+//
+
+class RoundRobin : public LoadBalancingPolicy {
+ public:
+  explicit RoundRobin(Args args);
+
+  absl::string_view name() const override { return kRoundRobin; }
+
+  absl::Status UpdateLocked(UpdateArgs args) override;
+  void ResetBackoffLocked() override;
+
+ private:
+  class RoundRobinEndpointList : public EndpointList {
+   public:
+    RoundRobinEndpointList(RefCountedPtr<RoundRobin> round_robin,
+                           const ServerAddressList& addresses,
+                           const ChannelArgs& args)
+        : EndpointList(std::move(round_robin),
+                       GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)
+                           ? "RoundRobinEndpointList"
+                           : nullptr) {
+      Init(addresses, args,
+           [&](RefCountedPtr<RoundRobinEndpointList> endpoint_list,
+               const ServerAddress& address, const ChannelArgs& args) {
+             return MakeOrphanable<RoundRobinEndpoint>(
+                 std::move(endpoint_list), address, args,
+                 policy<RoundRobin>()->work_serializer());
+           });
+    }
+
+   private:
+    class RoundRobinEndpoint : public Endpoint {
+     public:
+      RoundRobinEndpoint(RefCountedPtr<RoundRobinEndpointList> endpoint_list,
+                         const ServerAddress& address, const ChannelArgs& args,
+                         std::shared_ptr<WorkSerializer> work_serializer)
+          : Endpoint(std::move(endpoint_list)) {
+        Init(address, args, std::move(work_serializer));
+      }
+
+     private:
+      // Called when the child policy reports a connectivity state update.
+      void OnStateUpdate(absl::optional<grpc_connectivity_state> old_state,
+                         grpc_connectivity_state new_state,
+                         const absl::Status& status) override;
+    };
+
+    LoadBalancingPolicy::ChannelControlHelper* channel_control_helper()
+        const override {
+      return policy<RoundRobin>()->channel_control_helper();
+    }
+
+    // Updates the counters of children in each state when a
+    // child transitions from old_state to new_state.
+    void UpdateStateCountersLocked(
+        absl::optional<grpc_connectivity_state> old_state,
+        grpc_connectivity_state new_state);
+
+    // Ensures that the right child list is used and then updates
+    // the RR policy's connectivity state based on the child list's
+    // state counters.
+    void MaybeUpdateRoundRobinConnectivityStateLocked(
+        absl::Status status_for_tf);
+
+    std::string CountersString() const {
+      return absl::StrCat("num_children=", size(), " num_ready=", num_ready_,
+                          " num_connecting=", num_connecting_,
+                          " num_transient_failure=", num_transient_failure_);
+    }
+
+    size_t num_ready_ = 0;
+    size_t num_connecting_ = 0;
+    size_t num_transient_failure_ = 0;
+
+    absl::Status last_failure_;
+  };
+
+  class Picker : public SubchannelPicker {
+   public:
+    Picker(RoundRobin* parent,
+           std::vector<RefCountedPtr<LoadBalancingPolicy::SubchannelPicker>>
+               pickers);
+
+    PickResult Pick(PickArgs args) override;
+
+   private:
+    // Using pointer value only, no ref held -- do not dereference!
+    RoundRobin* parent_;
+
+    std::atomic<size_t> last_picked_index_;
+    std::vector<RefCountedPtr<LoadBalancingPolicy::SubchannelPicker>> pickers_;
+  };
+
+  ~RoundRobin() override;
+
+  void ShutdownLocked() override;
+
+  // Current child list.
+  OrphanablePtr<RoundRobinEndpointList> endpoint_list_;
+  // Latest pending child list.
+  // When we get an updated address list, we create a new child list
+  // for it here, and we wait to swap it into endpoint_list_ until the new
+  // list becomes READY.
+  OrphanablePtr<RoundRobinEndpointList> latest_pending_endpoint_list_;
+
+  bool shutdown_ = false;
+
+  absl::BitGen bit_gen_;
+};
+
+//
+// RoundRobin::Picker
+//
+
+RoundRobin::Picker::Picker(
+    RoundRobin* parent,
+    std::vector<RefCountedPtr<LoadBalancingPolicy::SubchannelPicker>> pickers)
+    : parent_(parent), pickers_(std::move(pickers)) {
+  // For discussion on why we generate a random starting index for
+  // the picker, see https://github.com/grpc/grpc-go/issues/2580.
+  size_t index = absl::Uniform<size_t>(parent->bit_gen_, 0, pickers_.size());
+  last_picked_index_.store(index, std::memory_order_relaxed);
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
+    gpr_log(GPR_INFO,
+            "[RR %p picker %p] created picker from endpoint_list=%p "
+            "with %" PRIuPTR " READY children; last_picked_index_=%" PRIuPTR,
+            parent_, this, parent_->endpoint_list_.get(), pickers_.size(),
+            index);
+  }
+}
+
+RoundRobin::PickResult RoundRobin::Picker::Pick(PickArgs args) {
+  size_t index = last_picked_index_.fetch_add(1, std::memory_order_relaxed) %
+                 pickers_.size();
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
+    gpr_log(GPR_INFO,
+            "[RR %p picker %p] using picker index %" PRIuPTR ", picker=%p",
+            parent_, this, index, pickers_[index].get());
+  }
+  return pickers_[index]->Pick(args);
+}
+
+//
+// RoundRobin
+//
+
+RoundRobin::RoundRobin(Args args) : LoadBalancingPolicy(std::move(args)) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
+    gpr_log(GPR_INFO, "[RR %p] Created", this);
+  }
+}
+
+RoundRobin::~RoundRobin() {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
+    gpr_log(GPR_INFO, "[RR %p] Destroying Round Robin policy", this);
+  }
+  GPR_ASSERT(endpoint_list_ == nullptr);
+  GPR_ASSERT(latest_pending_endpoint_list_ == nullptr);
+}
+
+void RoundRobin::ShutdownLocked() {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
+    gpr_log(GPR_INFO, "[RR %p] Shutting down", this);
+  }
+  shutdown_ = true;
+  endpoint_list_.reset();
+  latest_pending_endpoint_list_.reset();
+}
+
+void RoundRobin::ResetBackoffLocked() {
+  endpoint_list_->ResetBackoffLocked();
+  if (latest_pending_endpoint_list_ != nullptr) {
+    latest_pending_endpoint_list_->ResetBackoffLocked();
+  }
+}
+
+absl::Status RoundRobin::UpdateLocked(UpdateArgs args) {
+  ServerAddressList addresses;
+  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());
+    }
+    addresses = std::move(*args.addresses);
+  } else {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
+      gpr_log(GPR_INFO, "[RR %p] received update with address error: %s", this,
+              args.addresses.status().ToString().c_str());
+    }
+    // If we already have a child list, then keep using the existing
+    // list, but still report back that the update was not accepted.
+    if (endpoint_list_ != nullptr) return args.addresses.status();
+  }
+  // Create new child list, replacing the previous pending list, if any.
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace) &&
+      latest_pending_endpoint_list_ != nullptr) {
+    gpr_log(GPR_INFO, "[RR %p] replacing previous pending child list %p", this,
+            latest_pending_endpoint_list_.get());
+  }
+  latest_pending_endpoint_list_ = MakeOrphanable<RoundRobinEndpointList>(
+      Ref(DEBUG_LOCATION, "RoundRobinEndpointList"), std::move(addresses),
+      args.args);
+  // If the new list is empty, immediately promote it to
+  // endpoint_list_ and report TRANSIENT_FAILURE.
+  // TODO(roth): As part of adding dualstack backend support, we need to
+  // also handle the case where the list of addresses for a given
+  // endpoint is empty.
+  if (latest_pending_endpoint_list_->size() == 0) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace) &&
+        endpoint_list_ != nullptr) {
+      gpr_log(GPR_INFO, "[RR %p] replacing previous child list %p", this,
+              endpoint_list_.get());
+    }
+    endpoint_list_ = std::move(latest_pending_endpoint_list_);
+    absl::Status status =
+        args.addresses.ok() ? absl::UnavailableError(absl::StrCat(
+                                  "empty address list: ", args.resolution_note))
+                            : args.addresses.status();
+    channel_control_helper()->UpdateState(
+        GRPC_CHANNEL_TRANSIENT_FAILURE, status,
+        MakeRefCounted<TransientFailurePicker>(status));
+    return status;
+  }
+  // Otherwise, if this is the initial update, immediately promote it to
+  // endpoint_list_.
+  if (endpoint_list_ == nullptr) {
+    endpoint_list_ = std::move(latest_pending_endpoint_list_);
+  }
+  return absl::OkStatus();
+}
+
+//
+// RoundRobin::RoundRobinEndpointList::RoundRobinEndpoint
+//
+
+void RoundRobin::RoundRobinEndpointList::RoundRobinEndpoint::OnStateUpdate(
+    absl::optional<grpc_connectivity_state> old_state,
+    grpc_connectivity_state new_state, const absl::Status& status) {
+  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());
+  }
+  if (new_state == GRPC_CHANNEL_IDLE) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
+      gpr_log(GPR_INFO, "[RR %p] child %p reported IDLE; requesting connection",
+              round_robin, this);
+    }
+    ExitIdleLocked();
+  }
+  // If state changed, update state counters.
+  if (!old_state.has_value() || *old_state != new_state) {
+    rr_endpoint_list->UpdateStateCountersLocked(old_state, new_state);
+  }
+  // Update the policy state.
+  rr_endpoint_list->MaybeUpdateRoundRobinConnectivityStateLocked(status);
+}
+
+//
+// RoundRobin::RoundRobinEndpointList
+//
+
+void RoundRobin::RoundRobinEndpointList::UpdateStateCountersLocked(
+    absl::optional<grpc_connectivity_state> old_state,
+    grpc_connectivity_state new_state) {
+  // We treat IDLE the same as CONNECTING, since it will immediately
+  // transition into that state anyway.
+  if (old_state.has_value()) {
+    GPR_ASSERT(*old_state != GRPC_CHANNEL_SHUTDOWN);
+    if (*old_state == GRPC_CHANNEL_READY) {
+      GPR_ASSERT(num_ready_ > 0);
+      --num_ready_;
+    } else if (*old_state == GRPC_CHANNEL_CONNECTING ||
+               *old_state == GRPC_CHANNEL_IDLE) {
+      GPR_ASSERT(num_connecting_ > 0);
+      --num_connecting_;
+    } else if (*old_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
+      GPR_ASSERT(num_transient_failure_ > 0);
+      --num_transient_failure_;
+    }
+  }
+  GPR_ASSERT(new_state != GRPC_CHANNEL_SHUTDOWN);
+  if (new_state == GRPC_CHANNEL_READY) {
+    ++num_ready_;
+  } else if (new_state == GRPC_CHANNEL_CONNECTING ||
+             new_state == GRPC_CHANNEL_IDLE) {
+    ++num_connecting_;
+  } else if (new_state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
+    ++num_transient_failure_;
+  }
+}
+
+void RoundRobin::RoundRobinEndpointList::
+    MaybeUpdateRoundRobinConnectivityStateLocked(absl::Status status_for_tf) {
+  auto* round_robin = policy<RoundRobin>();
+  // If this is latest_pending_endpoint_list_, then swap it into
+  // endpoint_list_ in the following cases:
+  // - endpoint_list_ has no READY children.
+  // - This list has at least one READY child and we have seen the
+  //   initial connectivity state notification for all children.
+  // - All of the children in this list are in TRANSIENT_FAILURE.
+  //   (This may cause the channel to go from READY to TRANSIENT_FAILURE,
+  //   but we're doing what the control plane told us to do.)
+  if (round_robin->latest_pending_endpoint_list_.get() == this &&
+      (round_robin->endpoint_list_->num_ready_ == 0 ||
+       (num_ready_ > 0 && AllEndpointsSeenInitialState()) ||
+       num_transient_failure_ == size())) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
+      const std::string old_counters_string =
+          round_robin->endpoint_list_ != nullptr
+              ? round_robin->endpoint_list_->CountersString()
+              : "";
+      gpr_log(GPR_INFO,
+              "[RR %p] swapping out child list %p (%s) in favor of %p (%s)",
+              round_robin, round_robin->endpoint_list_.get(),
+              old_counters_string.c_str(), this, CountersString().c_str());
+    }
+    round_robin->endpoint_list_ =
+        std::move(round_robin->latest_pending_endpoint_list_);
+  }
+  // Only set connectivity state if this is the current child list.
+  if (round_robin->endpoint_list_.get() != this) return;
+  // FIXME: scan children each time instead of keeping counters?
+  // First matching rule wins:
+  // 1) ANY child is READY => policy is READY.
+  // 2) ANY child is CONNECTING => policy is CONNECTING.
+  // 3) ALL children are TRANSIENT_FAILURE => policy is TRANSIENT_FAILURE.
+  if (num_ready_ > 0) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
+      gpr_log(GPR_INFO, "[RR %p] reporting READY with child list %p",
+              round_robin, this);
+    }
+    std::vector<RefCountedPtr<LoadBalancingPolicy::SubchannelPicker>> pickers;
+    for (const auto& endpoint : endpoints()) {
+      auto state = endpoint->connectivity_state();
+      if (state.has_value() && *state == GRPC_CHANNEL_READY) {
+        pickers.push_back(endpoint->picker());
+      }
+    }
+    GPR_ASSERT(!pickers.empty());
+    round_robin->channel_control_helper()->UpdateState(
+        GRPC_CHANNEL_READY, absl::OkStatus(),
+        MakeRefCounted<Picker>(round_robin, std::move(pickers)));
+  } else if (num_connecting_ > 0) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
+      gpr_log(GPR_INFO, "[RR %p] reporting CONNECTING with child list %p",
+              round_robin, this);
+    }
+    round_robin->channel_control_helper()->UpdateState(
+        GRPC_CHANNEL_CONNECTING, absl::Status(),
+        MakeRefCounted<QueuePicker>(nullptr));
+  } else if (num_transient_failure_ == size()) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_round_robin_trace)) {
+      gpr_log(GPR_INFO,
+              "[RR %p] reporting TRANSIENT_FAILURE with child list %p: %s",
+              round_robin, this, status_for_tf.ToString().c_str());
+    }
+    if (!status_for_tf.ok()) {
+      last_failure_ = absl::UnavailableError(
+          absl::StrCat("connections to all backends failing; last error: ",
+                       status_for_tf.message()));
+    }
+    round_robin->channel_control_helper()->UpdateState(
+        GRPC_CHANNEL_TRANSIENT_FAILURE, last_failure_,
+        MakeRefCounted<TransientFailurePicker>(last_failure_));
+  }
+}
+
 //
 // factory
 //
@@ -516,6 +897,9 @@ class RoundRobinFactory : public LoadBalancingPolicyFactory {
  public:
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
       LoadBalancingPolicy::Args args) const override {
+    if (!IsRoundRobinDelegateToPickFirstEnabled()) {
+      return MakeOrphanable<OldRoundRobin>(std::move(args));
+    }
     return MakeOrphanable<RoundRobin>(std::move(args));
   }