grpc 1.26.0 → 1.28.0

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

@@ -321,13 +321,13 @@ void RoundRobin::RoundRobinSubchannelList::
    */
   if (num_ready_ > 0) {
     /* 1) READY */
-    p->channel_control_helper()->UpdateState(GRPC_CHANNEL_READY,
-                                             MakeUnique<Picker>(p, this));
+    p->channel_control_helper()->UpdateState(
+        GRPC_CHANNEL_READY, absl::make_unique<Picker>(p, this));
   } else if (num_connecting_ > 0) {
     /* 2) CONNECTING */
     p->channel_control_helper()->UpdateState(
         GRPC_CHANNEL_CONNECTING,
-        MakeUnique<QueuePicker>(p->Ref(DEBUG_LOCATION, "QueuePicker")));
+        absl::make_unique<QueuePicker>(p->Ref(DEBUG_LOCATION, "QueuePicker")));
   } else if (num_transient_failure_ == num_subchannels()) {
     /* 3) TRANSIENT_FAILURE */
     grpc_error* error =
@@ -336,7 +336,7 @@ void RoundRobin::RoundRobinSubchannelList::
                            GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
     p->channel_control_helper()->UpdateState(
         GRPC_CHANNEL_TRANSIENT_FAILURE,
-        MakeUnique<TransientFailurePicker>(error));
+        absl::make_unique<TransientFailurePicker>(error));
   }
 }
 
@@ -453,7 +453,7 @@ void RoundRobin::UpdateLocked(UpdateArgs args) {
                            GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
     channel_control_helper()->UpdateState(
         GRPC_CHANNEL_TRANSIENT_FAILURE,
-        MakeUnique<TransientFailurePicker>(error));
+        absl::make_unique<TransientFailurePicker>(error));
     subchannel_list_ = std::move(latest_pending_subchannel_list_);
   } else if (subchannel_list_ == nullptr) {
     // If there is no current list, immediately promote the new list to
@@ -467,7 +467,7 @@ void RoundRobin::UpdateLocked(UpdateArgs args) {
   }
 }
 
-class ParsedRoundRobinConfig : public LoadBalancingPolicy::Config {
+class RoundRobinConfig : public LoadBalancingPolicy::Config {
  public:
   const char* name() const override { return kRoundRobin; }
 };
@@ -486,12 +486,8 @@ class RoundRobinFactory : public LoadBalancingPolicyFactory {
   const char* name() const override { return kRoundRobin; }
 
   RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
-      const grpc_json* json, grpc_error** /*error*/) const override {
-    if (json != nullptr) {
-      GPR_DEBUG_ASSERT(strcmp(json->key, name()) == 0);
-    }
-    return RefCountedPtr<LoadBalancingPolicy::Config>(
-        new ParsedRoundRobinConfig());
+      const Json& /*json*/, grpc_error** /*error*/) const override {
+    return MakeRefCounted<RoundRobinConfig>();
   }
 };
 
@@ -502,7 +498,7 @@ class RoundRobinFactory : public LoadBalancingPolicyFactory {
 void grpc_lb_policy_round_robin_init() {
   grpc_core::LoadBalancingPolicyRegistry::Builder::
       RegisterLoadBalancingPolicyFactory(
-          grpc_core::MakeUnique<grpc_core::RoundRobinFactory>());
+          absl::make_unique<grpc_core::RoundRobinFactory>());
 }
 
 void grpc_lb_policy_round_robin_shutdown() {}

data/src/core/ext/filters/client_channel/lb_policy/xds/cds.cc

@@ -36,16 +36,15 @@ namespace {
 
 constexpr char kCds[] = "cds_experimental";
 
-// Parsed config for this LB policy.
-class ParsedCdsConfig : public LoadBalancingPolicy::Config {
+// Config for this LB policy.
+class CdsConfig : public LoadBalancingPolicy::Config {
  public:
-  explicit ParsedCdsConfig(grpc_core::UniquePtr<char> cluster)
-      : cluster_(std::move(cluster)) {}
-  const char* cluster() const { return cluster_.get(); }
+  explicit CdsConfig(std::string cluster) : cluster_(std::move(cluster)) {}
+  const std::string& cluster() const { return cluster_; }
   const char* name() const override { return kCds; }
 
  private:
-  grpc_core::UniquePtr<char> cluster_;
+  std::string cluster_;
 };
 
 // CDS LB policy.
@@ -64,7 +63,7 @@ class CdsLb : public LoadBalancingPolicy {
    public:
     explicit ClusterWatcher(RefCountedPtr<CdsLb> parent)
         : parent_(std::move(parent)) {}
-    void OnClusterChanged(CdsUpdate cluster_data) override;
+    void OnClusterChanged(XdsApi::CdsUpdate cluster_data) override;
     void OnError(grpc_error* error) override;
 
    private:
@@ -90,7 +89,7 @@ class CdsLb : public LoadBalancingPolicy {
 
   void ShutdownLocked() override;
 
-  RefCountedPtr<ParsedCdsConfig> config_;
+  RefCountedPtr<CdsConfig> config_;
 
   // Current channel args from the resolver.
   const grpc_channel_args* args_ = nullptr;
@@ -112,47 +111,40 @@ class CdsLb : public LoadBalancingPolicy {
 // CdsLb::ClusterWatcher
 //
 
-void CdsLb::ClusterWatcher::OnClusterChanged(CdsUpdate cluster_data) {
+void CdsLb::ClusterWatcher::OnClusterChanged(XdsApi::CdsUpdate cluster_data) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_cds_lb_trace)) {
-    gpr_log(GPR_INFO, "[cdslb %p] received CDS update from xds client",
-            parent_.get());
+    gpr_log(GPR_INFO,
+            "[cdslb %p] received CDS update from xds client %p: "
+            "eds_service_name=%s lrs_load_reporting_server_name=%s",
+            parent_.get(), parent_->xds_client_.get(),
+            cluster_data.eds_service_name.c_str(),
+            cluster_data.lrs_load_reporting_server_name.has_value()
+                ? cluster_data.lrs_load_reporting_server_name.value().c_str()
+                : "(unset)");
   }
   // Construct config for child policy.
-  char* lrs_str = nullptr;
-  if (cluster_data.lrs_load_reporting_server_name != nullptr) {
-    gpr_asprintf(&lrs_str, "    \"lrsLoadReportingServerName\": \"%s\",\n",
-                 cluster_data.lrs_load_reporting_server_name.get());
+  Json::Object child_config = {
+      {"edsServiceName",
+       (cluster_data.eds_service_name.empty() ? parent_->config_->cluster()
+                                              : cluster_data.eds_service_name)},
+  };
+  if (cluster_data.lrs_load_reporting_server_name.has_value()) {
+    child_config["lrsLoadReportingServerName"] =
+        cluster_data.lrs_load_reporting_server_name.value();
   }
-  char* json_str;
-  gpr_asprintf(&json_str,
-               "[{\n"
-               "  \"xds_experimental\": {\n"
-               "%s"
-               "    \"edsServiceName\": \"%s\"\n"
-               "  }\n"
-               "}]",
-               (lrs_str == nullptr ? "" : lrs_str),
-               (cluster_data.eds_service_name == nullptr
-                    ? parent_->config_->cluster()
-                    : cluster_data.eds_service_name.get()));
-  gpr_free(lrs_str);
-  grpc_core::UniquePtr<char> json_str_deleter(json_str);
+  Json json = Json::Array{
+      Json::Object{
+          {"xds_experimental", std::move(child_config)},
+      },
+  };
   if (GRPC_TRACE_FLAG_ENABLED(grpc_cds_lb_trace)) {
+    std::string json_str = json.Dump();
     gpr_log(GPR_INFO, "[cdslb %p] generated config for child policy: %s",
-            parent_.get(), json_str);
-  }
-  grpc_json* json = grpc_json_parse_string(json_str);
-  if (json == nullptr) {
-    char* msg;
-    gpr_asprintf(&msg, "Could not parse LB config: %s", json_str);
-    OnError(GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg));
-    gpr_free(msg);
-    return;
+            parent_.get(), json_str.c_str());
   }
   grpc_error* error = GRPC_ERROR_NONE;
   RefCountedPtr<LoadBalancingPolicy::Config> config =
       LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(json, &error);
-  grpc_json_destroy(json);
   if (error != GRPC_ERROR_NONE) {
     OnError(error);
     return;
@@ -162,13 +154,22 @@ void CdsLb::ClusterWatcher::OnClusterChanged(CdsUpdate cluster_data) {
     LoadBalancingPolicy::Args args;
     args.combiner = parent_->combiner();
     args.args = parent_->args_;
-    args.channel_control_helper = MakeUnique<Helper>(parent_->Ref());
+    args.channel_control_helper = absl::make_unique<Helper>(parent_->Ref());
     parent_->child_policy_ =
         LoadBalancingPolicyRegistry::CreateLoadBalancingPolicy(
             "xds_experimental", std::move(args));
+    if (parent_->child_policy_ == nullptr) {
+      OnError(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "failed to create xds_experimental child policy"));
+      return;
+    }
     grpc_pollset_set_add_pollset_set(
         parent_->child_policy_->interested_parties(),
         parent_->interested_parties());
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_cds_lb_trace)) {
+      gpr_log(GPR_INFO, "[cdslb %p] created child policy xds_experimental (%p)",
+              parent_.get(), parent_->child_policy_.get());
+    }
   }
   // Update child policy.
   UpdateArgs args;
@@ -179,14 +180,15 @@ void CdsLb::ClusterWatcher::OnClusterChanged(CdsUpdate cluster_data) {
 
 void CdsLb::ClusterWatcher::OnError(grpc_error* error) {
   gpr_log(GPR_ERROR, "[cdslb %p] xds error obtaining data for cluster %s: %s",
-          parent_.get(), parent_->config_->cluster(), grpc_error_string(error));
+          parent_.get(), parent_->config_->cluster().c_str(),
+          grpc_error_string(error));
   // Go into TRANSIENT_FAILURE if we have not yet created the child
   // policy (i.e., we have not yet received data from xds).  Otherwise,
   // we keep running with the data we had previously.
   if (parent_->child_policy_ == nullptr) {
     parent_->channel_control_helper()->UpdateState(
         GRPC_CHANNEL_TRANSIENT_FAILURE,
-        MakeUnique<TransientFailurePicker>(error));
+        absl::make_unique<TransientFailurePicker>(error));
   } else {
     GRPC_ERROR_UNREF(error);
   }
@@ -233,9 +235,9 @@ void CdsLb::Helper::AddTraceEvent(TraceSeverity severity, StringView message) {
 CdsLb::CdsLb(Args args)
     : LoadBalancingPolicy(std::move(args)),
       xds_client_(XdsClient::GetFromChannelArgs(*args.args)) {
-  if (xds_client_ != nullptr && GRPC_TRACE_FLAG_ENABLED(grpc_cds_lb_trace)) {
-    gpr_log(GPR_INFO, "[cdslb %p] Using xds client %p from channel", this,
-            xds_client_.get());
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_cds_lb_trace)) {
+    gpr_log(GPR_INFO, "[cdslb %p] created -- using xds client %p from channel",
+            this, xds_client_.get());
   }
 }
 
@@ -258,8 +260,12 @@ void CdsLb::ShutdownLocked() {
   }
   if (xds_client_ != nullptr) {
     if (cluster_watcher_ != nullptr) {
-      xds_client_->CancelClusterDataWatch(StringView(config_->cluster()),
-                                          cluster_watcher_);
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_cds_lb_trace)) {
+        gpr_log(GPR_INFO, "[cdslb %p] cancelling watch for cluster %s", this,
+                config_->cluster().c_str());
+      }
+      xds_client_->CancelClusterDataWatch(
+          StringView(config_->cluster().c_str()), cluster_watcher_);
     }
     xds_client_.reset();
   }
@@ -270,26 +276,35 @@ void CdsLb::ResetBackoffLocked() {
 }
 
 void CdsLb::UpdateLocked(UpdateArgs args) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_cds_lb_trace)) {
-    gpr_log(GPR_INFO, "[cdslb %p] received update", this);
-  }
   // Update config.
   auto old_config = std::move(config_);
   config_ = std::move(args.config);
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_cds_lb_trace)) {
+    gpr_log(GPR_INFO, "[cdslb %p] received update: cluster=%s", this,
+            config_->cluster().c_str());
+  }
   // Update args.
   grpc_channel_args_destroy(args_);
   args_ = args.args;
   args.args = nullptr;
   // If cluster name changed, cancel watcher and restart.
-  if (old_config == nullptr ||
-      strcmp(old_config->cluster(), config_->cluster()) != 0) {
+  if (old_config == nullptr || old_config->cluster() != config_->cluster()) {
     if (old_config != nullptr) {
-      xds_client_->CancelClusterDataWatch(StringView(old_config->cluster()),
-                                          cluster_watcher_);
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_cds_lb_trace)) {
+        gpr_log(GPR_INFO, "[cdslb %p] cancelling watch for cluster %s", this,
+                old_config->cluster().c_str());
+      }
+      xds_client_->CancelClusterDataWatch(
+          StringView(old_config->cluster().c_str()), cluster_watcher_,
+          /*delay_unsubscription=*/true);
+    }
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_cds_lb_trace)) {
+      gpr_log(GPR_INFO, "[cdslb %p] starting watch for cluster %s", this,
+              config_->cluster().c_str());
     }
-    auto watcher = MakeUnique<ClusterWatcher>(Ref());
+    auto watcher = absl::make_unique<ClusterWatcher>(Ref());
     cluster_watcher_ = watcher.get();
-    xds_client_->WatchClusterData(StringView(config_->cluster()),
+    xds_client_->WatchClusterData(StringView(config_->cluster().c_str()),
                                   std::move(watcher));
   }
 }
@@ -308,9 +323,9 @@ class CdsFactory : public LoadBalancingPolicyFactory {
   const char* name() const override { return kCds; }
 
   RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
-      const grpc_json* json, grpc_error** error) const override {
+      const Json& json, grpc_error** error) const override {
     GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
-    if (json == nullptr) {
+    if (json.type() == Json::Type::JSON_NULL) {
       // xds was mentioned as a policy in the deprecated loadBalancingPolicy
       // field or in the client API.
       *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
@@ -318,36 +333,23 @@ class CdsFactory : public LoadBalancingPolicyFactory {
           "Please use loadBalancingConfig field of service config instead.");
       return nullptr;
     }
-    GPR_DEBUG_ASSERT(strcmp(json->key, name()) == 0);
-    InlinedVector<grpc_error*, 3> error_list;
-    const char* cluster = nullptr;
-    for (const grpc_json* field = json->child; field != nullptr;
-         field = field->next) {
-      if (field->key == nullptr) continue;
-      if (strcmp(field->key, "cluster") == 0) {
-        if (cluster != nullptr) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:cluster error:Duplicate entry"));
-        }
-        if (field->type != GRPC_JSON_STRING) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:cluster error:type should be string"));
-          continue;
-        }
-        cluster = field->value;
-      }
-    }
-    if (cluster == nullptr) {
+    std::vector<grpc_error*> error_list;
+    std::string cluster;
+    auto it = json.object_value().find("cluster");
+    if (it == json.object_value().end()) {
       error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "required field 'cluster' not present"));
-    }
-    if (error_list.empty()) {
-      return MakeRefCounted<ParsedCdsConfig>(
-          grpc_core::UniquePtr<char>(gpr_strdup(cluster)));
+    } else if (it->second.type() != Json::Type::STRING) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:cluster error:type should be string"));
     } else {
+      cluster = it->second.string_value();
+    }
+    if (!error_list.empty()) {
       *error = GRPC_ERROR_CREATE_FROM_VECTOR("Cds Parser", &error_list);
       return nullptr;
     }
+    return MakeRefCounted<CdsConfig>(std::move(cluster));
   }
 };
 
@@ -362,7 +364,7 @@ class CdsFactory : public LoadBalancingPolicyFactory {
 void grpc_lb_policy_cds_init() {
   grpc_core::LoadBalancingPolicyRegistry::Builder::
       RegisterLoadBalancingPolicyFactory(
-          grpc_core::MakeUnique<grpc_core::CdsFactory>());
+          absl::make_unique<grpc_core::CdsFactory>());
 }
 
 void grpc_lb_policy_cds_shutdown() {}

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

@@ -25,6 +25,8 @@
 #include <limits.h>
 #include <string.h>
 
+#include "absl/types/optional.h"
+
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
@@ -32,6 +34,7 @@
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
 #include "src/core/ext/filters/client_channel/lb_policy.h"
+#include "src/core/ext/filters/client_channel/lb_policy/child_policy_handler.h"
 #include "src/core/ext/filters/client_channel/lb_policy/xds/xds.h"
 #include "src/core/ext/filters/client_channel/lb_policy_factory.h"
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
@@ -68,18 +71,18 @@
 
 namespace grpc_core {
 
-TraceFlag grpc_lb_xds_trace(false, "xds");
+TraceFlag grpc_lb_xds_trace(false, "xds_lb");
 
 namespace {
 
 constexpr char kXds[] = "xds_experimental";
 
-class ParsedXdsConfig : public LoadBalancingPolicy::Config {
+class XdsConfig : public LoadBalancingPolicy::Config {
  public:
-  ParsedXdsConfig(RefCountedPtr<LoadBalancingPolicy::Config> child_policy,
-                  RefCountedPtr<LoadBalancingPolicy::Config> fallback_policy,
-                  grpc_core::UniquePtr<char> eds_service_name,
-                  grpc_core::UniquePtr<char> lrs_load_reporting_server_name)
+  XdsConfig(RefCountedPtr<LoadBalancingPolicy::Config> child_policy,
+            RefCountedPtr<LoadBalancingPolicy::Config> fallback_policy,
+            std::string eds_service_name,
+            absl::optional<std::string> lrs_load_reporting_server_name)
       : child_policy_(std::move(child_policy)),
         fallback_policy_(std::move(fallback_policy)),
         eds_service_name_(std::move(eds_service_name)),
@@ -96,17 +99,19 @@ class ParsedXdsConfig : public LoadBalancingPolicy::Config {
     return fallback_policy_;
   }
 
-  const char* eds_service_name() const { return eds_service_name_.get(); };
+  const char* eds_service_name() const {
+    return eds_service_name_.empty() ? nullptr : eds_service_name_.c_str();
+  };
 
-  const char* lrs_load_reporting_server_name() const {
-    return lrs_load_reporting_server_name_.get();
+  const absl::optional<std::string>& lrs_load_reporting_server_name() const {
+    return lrs_load_reporting_server_name_;
   };
 
  private:
   RefCountedPtr<LoadBalancingPolicy::Config> child_policy_;
   RefCountedPtr<LoadBalancingPolicy::Config> fallback_policy_;
-  grpc_core::UniquePtr<char> eds_service_name_;
-  grpc_core::UniquePtr<char> lrs_load_reporting_server_name_;
+  std::string eds_service_name_;
+  absl::optional<std::string> lrs_load_reporting_server_name_;
 };
 
 class XdsLb : public LoadBalancingPolicy {
@@ -121,31 +126,42 @@ class XdsLb : public LoadBalancingPolicy {
  private:
   class EndpointWatcher;
 
-  // We need this wrapper for the following reasons:
-  // 1. To process per-locality load reporting.
-  // 2. Since pickers are std::unique_ptrs we use this RefCounted wrapper to
-  // control
-  //     references to it by the xds picker and the locality.
-  class EndpointPickerWrapper : public RefCounted<EndpointPickerWrapper> {
+  // A simple wrapper to convert the picker returned from a locality's child
+  // policy as a unique_ptr<> to a RefCountedPtr<>.  This allows it to be
+  // referenced by both the picker and the locality.
+  class RefCountedEndpointPicker : public RefCounted<RefCountedEndpointPicker> {
+   public:
+    explicit RefCountedEndpointPicker(std::unique_ptr<SubchannelPicker> picker)
+        : picker_(std::move(picker)) {}
+    PickResult Pick(PickArgs args) { return picker_->Pick(std::move(args)); }
+
+   private:
+    std::unique_ptr<SubchannelPicker> picker_;
+  };
+
+  // A picker that wraps the RefCountedEndpointPicker and performs load
+  // reporting for the locality.
+  class LoadReportingPicker : public RefCounted<LoadReportingPicker> {
    public:
-    EndpointPickerWrapper(
-        std::unique_ptr<SubchannelPicker> picker,
-        RefCountedPtr<XdsClientStats::LocalityStats> locality_stats)
+    LoadReportingPicker(RefCountedPtr<RefCountedEndpointPicker> picker,
+                        RefCountedPtr<XdsClusterLocalityStats> locality_stats)
         : picker_(std::move(picker)),
-          locality_stats_(std::move(locality_stats)) {
-      locality_stats_->RefByPicker();
-    }
-    ~EndpointPickerWrapper() { locality_stats_->UnrefByPicker(); }
+          locality_stats_(std::move(locality_stats)) {}
 
     PickResult Pick(PickArgs args);
 
+    RefCountedEndpointPicker* picker() const { return picker_.get(); }
+    XdsClusterLocalityStats* locality_stats() const {
+      return locality_stats_.get();
+    }
+
    private:
-    std::unique_ptr<SubchannelPicker> picker_;
-    RefCountedPtr<XdsClientStats::LocalityStats> locality_stats_;
+    RefCountedPtr<RefCountedEndpointPicker> picker_;
+    RefCountedPtr<XdsClusterLocalityStats> locality_stats_;
   };
 
-  // The picker will use a stateless weighting algorithm to pick the locality to
-  // use for each request.
+  // A picker that uses a stateless weighting algorithm to pick the locality
+  // to use for each request.
   class LocalityPicker : public SubchannelPicker {
    public:
     // Maintains a weighted list of pickers from each locality that is in ready
@@ -153,12 +169,12 @@ class XdsLb : public LoadBalancingPolicy {
     // proportional to the locality's weight. The start of the range is the
     // previous value in the vector and is 0 for the first element.
     using PickerList =
-        InlinedVector<std::pair<uint32_t, RefCountedPtr<EndpointPickerWrapper>>,
+        InlinedVector<std::pair<uint32_t, RefCountedPtr<LoadReportingPicker>>,
                       1>;
-    LocalityPicker(RefCountedPtr<XdsLb> xds_policy, PickerList pickers)
-        : xds_policy_(std::move(xds_policy)),
-          pickers_(std::move(pickers)),
-          drop_config_(xds_policy_->drop_config_) {}
+    LocalityPicker(XdsLb* xds_policy, PickerList pickers)
+        : drop_stats_(xds_policy->drop_stats_),
+          drop_config_(xds_policy->drop_config_),
+          pickers_(std::move(pickers)) {}
 
     PickResult Pick(PickArgs args) override;
 
@@ -166,9 +182,9 @@ class XdsLb : public LoadBalancingPolicy {
     // Calls the picker of the locality that the key falls within.
     PickResult PickFromLocality(const uint32_t key, PickArgs args);
 
-    RefCountedPtr<XdsLb> xds_policy_;
+    RefCountedPtr<XdsClusterDropStats> drop_stats_;
+    RefCountedPtr<XdsApi::DropConfig> drop_config_;
     PickerList pickers_;
-    RefCountedPtr<XdsDropConfig> drop_config_;
   };
 
   class FallbackHelper : public ChannelControlHelper {
@@ -185,219 +201,171 @@ class XdsLb : public LoadBalancingPolicy {
     void RequestReresolution() override;
     void AddTraceEvent(TraceSeverity severity, StringView message) override;
 
-    void set_child(LoadBalancingPolicy* child) { child_ = child; }
-
    private:
-    bool CalledByPendingFallback() const;
-    bool CalledByCurrentFallback() const;
-
     RefCountedPtr<XdsLb> parent_;
-    LoadBalancingPolicy* child_ = nullptr;
   };
 
-  // There is only one PriorityList instance, which has the same lifetime with
-  // the XdsLb instance.
-  class PriorityList {
+  // Each LocalityMap holds a ref to the XdsLb.
+  class LocalityMap : public InternallyRefCounted<LocalityMap> {
    public:
-    // Each LocalityMap holds a ref to the XdsLb.
-    class LocalityMap : public InternallyRefCounted<LocalityMap> {
+    // Each Locality holds a ref to the LocalityMap it is in.
+    class Locality : public InternallyRefCounted<Locality> {
      public:
-      // Each Locality holds a ref to the LocalityMap it is in.
-      class Locality : public InternallyRefCounted<Locality> {
-       public:
-        Locality(RefCountedPtr<LocalityMap> locality_map,
-                 RefCountedPtr<XdsLocalityName> name);
-        ~Locality();
-
-        void UpdateLocked(uint32_t locality_weight,
-                          ServerAddressList serverlist);
-        void ShutdownLocked();
-        void ResetBackoffLocked();
-        void DeactivateLocked();
-        void Orphan() override;
-
-        grpc_connectivity_state connectivity_state() const {
-          return connectivity_state_;
-        }
-        uint32_t weight() const { return weight_; }
-        RefCountedPtr<EndpointPickerWrapper> picker_wrapper() const {
-          return picker_wrapper_;
-        }
-
-        void set_locality_map(RefCountedPtr<LocalityMap> locality_map) {
-          locality_map_ = std::move(locality_map);
-        }
+      Locality(RefCountedPtr<LocalityMap> locality_map,
+               RefCountedPtr<XdsLocalityName> name);
+      ~Locality();
 
-       private:
-        class Helper : public ChannelControlHelper {
-         public:
-          explicit Helper(RefCountedPtr<Locality> locality)
-              : locality_(std::move(locality)) {}
-
-          ~Helper() { locality_.reset(DEBUG_LOCATION, "Helper"); }
-
-          RefCountedPtr<SubchannelInterface> CreateSubchannel(
-              const grpc_channel_args& args) override;
-          void UpdateState(grpc_connectivity_state state,
-                           std::unique_ptr<SubchannelPicker> picker) override;
-          // This is a no-op, because we get the addresses from the xds
-          // client, which is a watch-based API.
-          void RequestReresolution() override {}
-          void AddTraceEvent(TraceSeverity severity,
-                             StringView message) override;
-          void set_child(LoadBalancingPolicy* child) { child_ = child; }
-
-         private:
-          bool CalledByPendingChild() const;
-          bool CalledByCurrentChild() const;
-
-          RefCountedPtr<Locality> locality_;
-          LoadBalancingPolicy* child_ = nullptr;
-        };
-
-        // Methods for dealing with the child policy.
-        OrphanablePtr<LoadBalancingPolicy> CreateChildPolicyLocked(
-            const char* name, const grpc_channel_args* args);
-        grpc_channel_args* CreateChildPolicyArgsLocked(
-            const grpc_channel_args* args);
-
-        static void OnDelayedRemovalTimer(void* arg, grpc_error* error);
-        static void OnDelayedRemovalTimerLocked(void* arg, grpc_error* error);
-
-        XdsLb* xds_policy() const { return locality_map_->xds_policy(); }
-
-        // The owning locality map.
-        RefCountedPtr<LocalityMap> locality_map_;
-
-        RefCountedPtr<XdsLocalityName> name_;
-        OrphanablePtr<LoadBalancingPolicy> child_policy_;
-        OrphanablePtr<LoadBalancingPolicy> pending_child_policy_;
-        RefCountedPtr<EndpointPickerWrapper> picker_wrapper_;
-        grpc_connectivity_state connectivity_state_ = GRPC_CHANNEL_IDLE;
-        uint32_t weight_;
-
-        // States for delayed removal.
-        grpc_timer delayed_removal_timer_;
-        grpc_closure on_delayed_removal_timer_;
-        bool delayed_removal_timer_callback_pending_ = false;
-        bool shutdown_ = false;
-      };
-
-      LocalityMap(RefCountedPtr<XdsLb> xds_policy, uint32_t priority);
-
-      void UpdateLocked(
-          const XdsPriorityListUpdate::LocalityMap& locality_map_update);
+      void UpdateLocked(uint32_t locality_weight, ServerAddressList serverlist,
+                        bool update_locality_stats);
+      void ShutdownLocked();
       void ResetBackoffLocked();
-      void UpdateXdsPickerLocked();
-      OrphanablePtr<Locality> ExtractLocalityLocked(
-          const RefCountedPtr<XdsLocalityName>& name);
       void DeactivateLocked();
-      // Returns true if this locality map becomes the currently used one (i.e.,
-      // its priority is selected) after reactivation.
-      bool MaybeReactivateLocked();
-      void MaybeCancelFailoverTimerLocked();
-
       void Orphan() override;
 
-      XdsLb* xds_policy() const { return xds_policy_.get(); }
-      uint32_t priority() const { return priority_; }
+      uint32_t weight() const { return weight_; }
+
       grpc_connectivity_state connectivity_state() const {
         return connectivity_state_;
       }
-      bool failover_timer_callback_pending() const {
-        return failover_timer_callback_pending_;
+
+      RefCountedPtr<LoadReportingPicker> GetLoadReportingPicker() {
+        // Recreate load reporting picker if stats object has changed.
+        if (load_reporting_picker_ == nullptr ||
+            load_reporting_picker_->picker() != picker_wrapper_.get() ||
+            load_reporting_picker_->locality_stats() != stats_.get()) {
+          load_reporting_picker_ =
+              MakeRefCounted<LoadReportingPicker>(picker_wrapper_, stats_);
+        }
+        return load_reporting_picker_;
+      }
+
+      void set_locality_map(RefCountedPtr<LocalityMap> locality_map) {
+        locality_map_ = std::move(locality_map);
       }
 
      private:
-      void OnLocalityStateUpdateLocked();
-      void UpdateConnectivityStateLocked();
+      class Helper : public ChannelControlHelper {
+       public:
+        explicit Helper(RefCountedPtr<Locality> locality)
+            : locality_(std::move(locality)) {}
+
+        ~Helper() { locality_.reset(DEBUG_LOCATION, "Helper"); }
+
+        RefCountedPtr<SubchannelInterface> CreateSubchannel(
+            const grpc_channel_args& args) override;
+        void UpdateState(grpc_connectivity_state state,
+                         std::unique_ptr<SubchannelPicker> picker) override;
+        // This is a no-op, because we get the addresses from the xds
+        // client, which is a watch-based API.
+        void RequestReresolution() override {}
+        void AddTraceEvent(TraceSeverity severity, StringView message) override;
+
+       private:
+        RefCountedPtr<Locality> locality_;
+      };
+
+      // Methods for dealing with the child policy.
+      OrphanablePtr<LoadBalancingPolicy> CreateChildPolicyLocked(
+          const grpc_channel_args* args);
+      grpc_channel_args* CreateChildPolicyArgsLocked(
+          const grpc_channel_args* args);
+
+      void UpdateLocalityStats();
+
       static void OnDelayedRemovalTimer(void* arg, grpc_error* error);
-      static void OnFailoverTimer(void* arg, grpc_error* error);
       static void OnDelayedRemovalTimerLocked(void* arg, grpc_error* error);
-      static void OnFailoverTimerLocked(void* arg, grpc_error* error);
 
-      PriorityList* priority_list() const {
-        return &xds_policy_->priority_list_;
-      }
-      const XdsPriorityListUpdate& priority_list_update() const {
-        return xds_policy_->priority_list_update_;
-      }
-      const XdsPriorityListUpdate::LocalityMap* locality_map_update() const {
-        return xds_policy_->priority_list_update_.Find(priority_);
-      }
+      XdsLb* xds_policy() const { return locality_map_->xds_policy(); }
 
-      RefCountedPtr<XdsLb> xds_policy_;
+      // The owning locality map.
+      RefCountedPtr<LocalityMap> locality_map_;
 
-      std::map<RefCountedPtr<XdsLocalityName>, OrphanablePtr<Locality>,
-               XdsLocalityName::Less>
-          localities_;
-      const uint32_t priority_;
+      RefCountedPtr<XdsLocalityName> name_;
+      RefCountedPtr<XdsClusterLocalityStats> stats_;
+      OrphanablePtr<LoadBalancingPolicy> child_policy_;
+      RefCountedPtr<RefCountedEndpointPicker> picker_wrapper_;
+      RefCountedPtr<LoadReportingPicker> load_reporting_picker_;
       grpc_connectivity_state connectivity_state_ = GRPC_CHANNEL_IDLE;
+      uint32_t weight_;
 
       // States for delayed removal.
       grpc_timer delayed_removal_timer_;
       grpc_closure on_delayed_removal_timer_;
       bool delayed_removal_timer_callback_pending_ = false;
-
-      // States of failover.
-      grpc_timer failover_timer_;
-      grpc_closure on_failover_timer_;
-      bool failover_timer_callback_pending_ = false;
+      bool shutdown_ = false;
     };
 
-    explicit PriorityList(XdsLb* xds_policy) : xds_policy_(xds_policy) {}
+    LocalityMap(RefCountedPtr<XdsLb> xds_policy, uint32_t priority);
 
-    void UpdateLocked();
+    ~LocalityMap() { xds_policy_.reset(DEBUG_LOCATION, "LocalityMap"); }
+
+    void UpdateLocked(
+        const XdsApi::PriorityListUpdate::LocalityMap& priority_update,
+        bool update_locality_stats);
     void ResetBackoffLocked();
-    void ShutdownLocked();
     void UpdateXdsPickerLocked();
-
-    const XdsPriorityListUpdate& priority_list_update() const {
-      return xds_policy_->priority_list_update_;
+    OrphanablePtr<Locality> ExtractLocalityLocked(
+        const RefCountedPtr<XdsLocalityName>& name);
+    void DeactivateLocked();
+    // Returns true if this locality map becomes the currently used one (i.e.,
+    // its priority is selected) after reactivation.
+    bool MaybeReactivateLocked();
+    void MaybeCancelFailoverTimerLocked();
+
+    void Orphan() override;
+
+    XdsLb* xds_policy() const { return xds_policy_.get(); }
+    uint32_t priority() const { return priority_; }
+    grpc_connectivity_state connectivity_state() const {
+      return connectivity_state_;
+    }
+    bool failover_timer_callback_pending() const {
+      return failover_timer_callback_pending_;
     }
-    uint32_t current_priority() const { return current_priority_; }
 
    private:
-    void MaybeCreateLocalityMapLocked(uint32_t priority);
-    void FailoverOnConnectionFailureLocked();
-    void FailoverOnDisconnectionLocked(uint32_t failed_priority);
-    void SwitchToHigherPriorityLocked(uint32_t priority);
-    void DeactivatePrioritiesLowerThan(uint32_t priority);
-    OrphanablePtr<LocalityMap::Locality> ExtractLocalityLocked(
-        const RefCountedPtr<XdsLocalityName>& name, uint32_t exclude_priority);
-    // Callers should make sure the priority list is non-empty.
-    uint32_t LowestPriority() const {
-      return static_cast<uint32_t>(priorities_.size()) - 1;
+    void OnLocalityStateUpdateLocked();
+    void UpdateConnectivityStateLocked();
+    static void OnDelayedRemovalTimer(void* arg, grpc_error* error);
+    static void OnFailoverTimer(void* arg, grpc_error* error);
+    static void OnDelayedRemovalTimerLocked(void* arg, grpc_error* error);
+    static void OnFailoverTimerLocked(void* arg, grpc_error* error);
+
+    const XdsApi::PriorityListUpdate& priority_list_update() const {
+      return xds_policy_->priority_list_update_;
+    }
+    const XdsApi::PriorityListUpdate::LocalityMap* locality_map_update() const {
+      return xds_policy_->priority_list_update_.Find(priority_);
     }
-    bool Contains(uint32_t priority) { return priority < priorities_.size(); }
 
-    XdsLb* xds_policy_;
+    RefCountedPtr<XdsLb> xds_policy_;
 
-    // The list of locality maps, indexed by priority. P0 is the highest
-    // priority.
-    InlinedVector<OrphanablePtr<LocalityMap>, 2> priorities_;
-    // The priority that is being used.
-    uint32_t current_priority_ = UINT32_MAX;
+    std::map<RefCountedPtr<XdsLocalityName>, OrphanablePtr<Locality>,
+             XdsLocalityName::Less>
+        localities_;
+    const uint32_t priority_;
+    grpc_connectivity_state connectivity_state_ = GRPC_CHANNEL_IDLE;
+
+    // States for delayed removal.
+    grpc_timer delayed_removal_timer_;
+    grpc_closure on_delayed_removal_timer_;
+    bool delayed_removal_timer_callback_pending_ = false;
+
+    // States of failover.
+    grpc_timer failover_timer_;
+    grpc_closure on_failover_timer_;
+    bool failover_timer_callback_pending_ = false;
   };
 
   ~XdsLb();
 
   void ShutdownLocked() override;
 
-  // Methods for dealing with fallback state.
-  void MaybeCancelFallbackAtStartupChecks();
-  static void OnFallbackTimer(void* arg, grpc_error* error);
-  static void OnFallbackTimerLocked(void* arg, grpc_error* error);
-  void UpdateFallbackPolicyLocked();
-  OrphanablePtr<LoadBalancingPolicy> CreateFallbackPolicyLocked(
-      const char* name, const grpc_channel_args* args);
-  void MaybeExitFallbackMode();
-
   const char* eds_service_name() const {
     if (config_ != nullptr && config_->eds_service_name() != nullptr) {
       return config_->eds_service_name();
     }
-    return server_name_.get();
+    return server_name_.c_str();
   }
 
   XdsClient* xds_client() const {
@@ -405,12 +373,36 @@ class XdsLb : public LoadBalancingPolicy {
                                                : xds_client_.get();
   }
 
+  void UpdatePrioritiesLocked(bool update_locality_stats);
+  void UpdateXdsPickerLocked();
+  void MaybeCreateLocalityMapLocked(uint32_t priority);
+  void FailoverOnConnectionFailureLocked();
+  void FailoverOnDisconnectionLocked(uint32_t failed_priority);
+  void SwitchToHigherPriorityLocked(uint32_t priority);
+  void DeactivatePrioritiesLowerThan(uint32_t priority);
+  OrphanablePtr<LocalityMap::Locality> ExtractLocalityLocked(
+      const RefCountedPtr<XdsLocalityName>& name, uint32_t exclude_priority);
+  // Callers should make sure the priority list is non-empty.
+  uint32_t LowestPriority() const {
+    return static_cast<uint32_t>(priorities_.size()) - 1;
+  }
+  bool Contains(uint32_t priority) { return priority < priorities_.size(); }
+
+  // Methods for dealing with fallback state.
+  void MaybeCancelFallbackAtStartupChecks();
+  static void OnFallbackTimer(void* arg, grpc_error* error);
+  static void OnFallbackTimerLocked(void* arg, grpc_error* error);
+  void UpdateFallbackPolicyLocked();
+  OrphanablePtr<LoadBalancingPolicy> CreateFallbackPolicyLocked(
+      const grpc_channel_args* args);
+  void MaybeExitFallbackMode();
+
   // Server name from target URI.
-  grpc_core::UniquePtr<char> server_name_;
+  std::string server_name_;
 
   // Current channel args and config from the resolver.
   const grpc_channel_args* args_ = nullptr;
-  RefCountedPtr<ParsedXdsConfig> config_;
+  RefCountedPtr<XdsConfig> config_;
 
   // Internal state.
   bool shutting_down_ = false;
@@ -444,27 +436,29 @@ class XdsLb : public LoadBalancingPolicy {
 
   // Non-null iff we are in fallback mode.
   OrphanablePtr<LoadBalancingPolicy> fallback_policy_;
-  OrphanablePtr<LoadBalancingPolicy> pending_fallback_policy_;
 
   const grpc_millis locality_retention_interval_ms_;
   const grpc_millis locality_map_failover_timeout_ms_;
-  // A list of locality maps indexed by priority.
-  PriorityList priority_list_;
+  // The list of locality maps, indexed by priority. P0 is the highest
+  // priority.
+  InlinedVector<OrphanablePtr<LocalityMap>, 2> priorities_;
+  // The priority that is being used.
+  uint32_t current_priority_ = UINT32_MAX;
   // The update for priority_list_.
-  XdsPriorityListUpdate priority_list_update_;
+  XdsApi::PriorityListUpdate priority_list_update_;
 
   // The config for dropping calls.
-  RefCountedPtr<XdsDropConfig> drop_config_;
+  RefCountedPtr<XdsApi::DropConfig> drop_config_;
 
-  // The stats for client-side load reporting.
-  XdsClientStats client_stats_;
+  // Drop stats for client-side load reporting.
+  RefCountedPtr<XdsClusterDropStats> drop_stats_;
 };
 
 //
-// XdsLb::EndpointPickerWrapper
+// XdsLb::LoadReportingPicker
 //
 
-LoadBalancingPolicy::PickResult XdsLb::EndpointPickerWrapper::Pick(
+LoadBalancingPolicy::PickResult XdsLb::LoadReportingPicker::Pick(
     LoadBalancingPolicy::PickArgs args) {
   // Forward the pick to the picker returned from the child policy.
   PickResult result = picker_->Pick(args);
@@ -475,7 +469,7 @@ LoadBalancingPolicy::PickResult XdsLb::EndpointPickerWrapper::Pick(
   // Record a call started.
   locality_stats_->AddCallStarted();
   // Intercept the recv_trailing_metadata op to record call completion.
-  XdsClientStats::LocalityStats* locality_stats =
+  XdsClusterLocalityStats* locality_stats =
       locality_stats_->Ref(DEBUG_LOCATION, "LocalityStats+call").release();
   result.recv_trailing_metadata_ready =
       // Note: This callback does not run in either the control plane
@@ -495,13 +489,23 @@ LoadBalancingPolicy::PickResult XdsLb::EndpointPickerWrapper::Pick(
 
 XdsLb::PickResult XdsLb::LocalityPicker::Pick(PickArgs args) {
   // Handle drop.
-  const grpc_core::UniquePtr<char>* drop_category;
+  const std::string* drop_category;
   if (drop_config_->ShouldDrop(&drop_category)) {
-    xds_policy_->client_stats_.AddCallDropped(*drop_category);
+    if (drop_stats_ != nullptr) drop_stats_->AddCallDropped(*drop_category);
     PickResult result;
     result.type = PickResult::PICK_COMPLETE;
     return result;
   }
+  // If we didn't drop, we better have some localities to pick from.
+  if (pickers_.empty()) {  // Should never happen.
+    PickResult result;
+    result.type = PickResult::PICK_FAILED;
+    result.error =
+        grpc_error_set_int(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+                               "xds picker not given any localities"),
+                           GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_INTERNAL);
+    return result;
+  }
   // Generate a random number in [0, total weight).
   const uint32_t key = rand() % pickers_[pickers_.size() - 1].first;
   // Forward pick to whichever locality maps to the range in which the
@@ -535,71 +539,26 @@ XdsLb::PickResult XdsLb::LocalityPicker::PickFromLocality(const uint32_t key,
 // XdsLb::FallbackHelper
 //
 
-bool XdsLb::FallbackHelper::CalledByPendingFallback() const {
-  GPR_ASSERT(child_ != nullptr);
-  return child_ == parent_->pending_fallback_policy_.get();
-}
-
-bool XdsLb::FallbackHelper::CalledByCurrentFallback() const {
-  GPR_ASSERT(child_ != nullptr);
-  return child_ == parent_->fallback_policy_.get();
-}
-
 RefCountedPtr<SubchannelInterface> XdsLb::FallbackHelper::CreateSubchannel(
     const grpc_channel_args& args) {
-  if (parent_->shutting_down_ ||
-      (!CalledByPendingFallback() && !CalledByCurrentFallback())) {
-    return nullptr;
-  }
+  if (parent_->shutting_down_) return nullptr;
   return parent_->channel_control_helper()->CreateSubchannel(args);
 }
 
 void XdsLb::FallbackHelper::UpdateState(
     grpc_connectivity_state state, std::unique_ptr<SubchannelPicker> picker) {
   if (parent_->shutting_down_) return;
-  // If this request is from the pending fallback policy, ignore it until
-  // it reports READY, at which point we swap it into place.
-  if (CalledByPendingFallback()) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
-      gpr_log(
-          GPR_INFO,
-          "[xdslb %p helper %p] pending fallback policy %p reports state=%s",
-          parent_.get(), this, parent_->pending_fallback_policy_.get(),
-          ConnectivityStateName(state));
-    }
-    if (state != GRPC_CHANNEL_READY) return;
-    grpc_pollset_set_del_pollset_set(
-        parent_->fallback_policy_->interested_parties(),
-        parent_->interested_parties());
-    parent_->fallback_policy_ = std::move(parent_->pending_fallback_policy_);
-  } else if (!CalledByCurrentFallback()) {
-    // This request is from an outdated fallback policy, so ignore it.
-    return;
-  }
   parent_->channel_control_helper()->UpdateState(state, std::move(picker));
 }
 
 void XdsLb::FallbackHelper::RequestReresolution() {
   if (parent_->shutting_down_) return;
-  const LoadBalancingPolicy* latest_fallback_policy =
-      parent_->pending_fallback_policy_ != nullptr
-          ? parent_->pending_fallback_policy_.get()
-          : parent_->fallback_policy_.get();
-  if (child_ != latest_fallback_policy) return;
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
-    gpr_log(GPR_INFO,
-            "[xdslb %p] Re-resolution requested from the fallback policy (%p).",
-            parent_.get(), child_);
-  }
   parent_->channel_control_helper()->RequestReresolution();
 }
 
 void XdsLb::FallbackHelper::AddTraceEvent(TraceSeverity severity,
                                           StringView message) {
-  if (parent_->shutting_down_ ||
-      (!CalledByPendingFallback() && !CalledByCurrentFallback())) {
-    return;
-  }
+  if (parent_->shutting_down_) return;
   parent_->channel_control_helper()->AddTraceEvent(severity, message);
 }
 
@@ -612,14 +571,16 @@ class XdsLb::EndpointWatcher : public XdsClient::EndpointWatcherInterface {
   explicit EndpointWatcher(RefCountedPtr<XdsLb> xds_policy)
       : xds_policy_(std::move(xds_policy)) {}
 
-  void OnEndpointChanged(EdsUpdate update) override {
+  ~EndpointWatcher() { xds_policy_.reset(DEBUG_LOCATION, "EndpointWatcher"); }
+
+  void OnEndpointChanged(XdsApi::EdsUpdate update) override {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
       gpr_log(GPR_INFO, "[xdslb %p] Received EDS update from xds client",
               xds_policy_.get());
     }
     // If the balancer tells us to drop all the calls, we should exit fallback
     // mode immediately.
-    if (update.drop_all) xds_policy_->MaybeExitFallbackMode();
+    if (update.drop_config->drop_all()) xds_policy_->MaybeExitFallbackMode();
     // Update the drop config.
     const bool drop_config_changed =
         xds_policy_->drop_config_ == nullptr ||
@@ -634,13 +595,13 @@ class XdsLb::EndpointWatcher : public XdsClient::EndpointWatcherInterface {
                 xds_policy_.get(), drop_config_changed);
       }
       if (drop_config_changed) {
-        xds_policy_->priority_list_.UpdateXdsPickerLocked();
+        xds_policy_->UpdateXdsPickerLocked();
       }
       return;
     }
     // Update the priority list.
     xds_policy_->priority_list_update_ = std::move(update.priority_list_update);
-    xds_policy_->priority_list_.UpdateLocked();
+    xds_policy_->UpdatePrioritiesLocked(false /*update_locality_stats*/);
   }
 
   void OnError(grpc_error* error) override {
@@ -670,6 +631,9 @@ class XdsLb::EndpointWatcher : public XdsClient::EndpointWatcherInterface {
       if (strstr(grpc_error_string(error), "xds call failed")) {
         xds_policy_->channel_control_helper()->RequestReresolution();
       }
+    } else if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
+      gpr_log(GPR_INFO, "[xdslb %p] xds watcher reported error (ignoring): %s",
+              xds_policy_.get(), grpc_error_string(error));
     }
     GRPC_ERROR_UNREF(error);
   }
@@ -693,11 +657,9 @@ XdsLb::XdsLb(Args args)
           {GRPC_XDS_DEFAULT_LOCALITY_RETENTION_INTERVAL_MS, 0, INT_MAX})),
       locality_map_failover_timeout_ms_(grpc_channel_args_find_integer(
           args.args, GRPC_ARG_XDS_FAILOVER_TIMEOUT_MS,
-          {GRPC_XDS_DEFAULT_FAILOVER_TIMEOUT_MS, 0, INT_MAX})),
-      priority_list_(this) {
-  if (xds_client_from_channel_ != nullptr &&
-      GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
-    gpr_log(GPR_INFO, "[xdslb %p] Using xds client %p from channel", this,
+          {GRPC_XDS_DEFAULT_FAILOVER_TIMEOUT_MS, 0, INT_MAX})) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
+    gpr_log(GPR_INFO, "[xdslb %p] created -- xds client from channel: %p", this,
             xds_client_from_channel_.get());
   }
   // Record server name.
@@ -706,11 +668,10 @@ XdsLb::XdsLb(Args args)
   GPR_ASSERT(server_uri != nullptr);
   grpc_uri* uri = grpc_uri_parse(server_uri, true);
   GPR_ASSERT(uri->path[0] != '\0');
-  server_name_.reset(
-      gpr_strdup(uri->path[0] == '/' ? uri->path + 1 : uri->path));
+  server_name_ = uri->path[0] == '/' ? uri->path + 1 : uri->path;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
     gpr_log(GPR_INFO, "[xdslb %p] server name from channel: %s", this,
-            server_name_.get());
+            server_name_.c_str());
   }
   grpc_uri_destroy(uri);
 }
@@ -728,27 +689,26 @@ void XdsLb::ShutdownLocked() {
   }
   shutting_down_ = true;
   MaybeCancelFallbackAtStartupChecks();
-  priority_list_.ShutdownLocked();
+  priorities_.clear();
+  drop_stats_.reset();
   if (fallback_policy_ != nullptr) {
     grpc_pollset_set_del_pollset_set(fallback_policy_->interested_parties(),
                                      interested_parties());
+    fallback_policy_.reset();
   }
-  if (pending_fallback_policy_ != nullptr) {
-    grpc_pollset_set_del_pollset_set(
-        pending_fallback_policy_->interested_parties(), interested_parties());
+  // Cancel the endpoint watch here instead of in our dtor if we are using the
+  // XdsResolver, because the watcher holds a ref to us and we might not be
+  // destroying the Xds client leading to a situation where the Xds lb policy is
+  // never destroyed.
+  if (xds_client_from_channel_ != nullptr) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
+      gpr_log(GPR_INFO, "[xdslb %p] cancelling watch for %s", this,
+              eds_service_name());
+    }
+    xds_client()->CancelEndpointDataWatch(StringView(eds_service_name()),
+                                          endpoint_watcher_);
+    xds_client_from_channel_.reset();
   }
-  fallback_policy_.reset();
-  pending_fallback_policy_.reset();
-  // Cancel the endpoint watch here instead of in our dtor, because the
-  // watcher holds a ref to us.
-  xds_client()->CancelEndpointDataWatch(StringView(eds_service_name()),
-                                        endpoint_watcher_);
-  if (config_->lrs_load_reporting_server_name() != nullptr) {
-    xds_client()->RemoveClientStats(
-        StringView(config_->lrs_load_reporting_server_name()),
-        StringView(eds_service_name()), &client_stats_);
-  }
-  xds_client_from_channel_.reset();
   xds_client_.reset();
 }
 
@@ -761,13 +721,12 @@ void XdsLb::ResetBackoffLocked() {
   // LB policy, this is done via the resolver, so we don't need to do it
   // for xds_client_from_channel_ here.
   if (xds_client_ != nullptr) xds_client_->ResetBackoff();
-  priority_list_.ResetBackoffLocked();
+  for (size_t i = 0; i < priorities_.size(); ++i) {
+    priorities_[i]->ResetBackoffLocked();
+  }
   if (fallback_policy_ != nullptr) {
     fallback_policy_->ResetBackoffLocked();
   }
-  if (pending_fallback_policy_ != nullptr) {
-    pending_fallback_policy_->ResetBackoffLocked();
-  }
 }
 
 void XdsLb::UpdateLocked(UpdateArgs args) {
@@ -776,7 +735,6 @@ void XdsLb::UpdateLocked(UpdateArgs args) {
   }
   const bool is_initial_update = args_ == nullptr;
   // Update config.
-  const char* old_eds_service_name = eds_service_name();
   auto old_config = std::move(config_);
   config_ = std::move(args.config);
   // Update fallback address list.
@@ -785,8 +743,6 @@ void XdsLb::UpdateLocked(UpdateArgs args) {
   grpc_channel_args_destroy(args_);
   args_ = args.args;
   args.args = nullptr;
-  // Update priority list.
-  priority_list_.UpdateLocked();
   // Update the existing fallback policy. The fallback policy config and/or the
   // fallback addresses may be new.
   if (fallback_policy_ != nullptr) UpdateFallbackPolicyLocked();
@@ -813,41 +769,40 @@ void XdsLb::UpdateLocked(UpdateArgs args) {
     fallback_at_startup_checks_pending_ = true;
     grpc_timer_init(&lb_fallback_timer_, deadline, &lb_on_fallback_);
   }
-  // Update endpoint watcher if needed.
-  if (is_initial_update ||
-      strcmp(old_eds_service_name, eds_service_name()) != 0) {
-    if (!is_initial_update) {
-      xds_client()->CancelEndpointDataWatch(StringView(old_eds_service_name),
-                                            endpoint_watcher_);
+  // Update drop stats for load reporting if needed.
+  if (is_initial_update || config_->lrs_load_reporting_server_name() !=
+                               old_config->lrs_load_reporting_server_name()) {
+    drop_stats_.reset();
+    if (config_->lrs_load_reporting_server_name().has_value()) {
+      drop_stats_ = xds_client()->AddClusterDropStats(
+          config_->lrs_load_reporting_server_name().value(),
+          // TODO(roth): We currently hard-code the assumption that
+          // cluster name and EDS service name are the same.  Fix this
+          // as part of refectoring this LB policy.
+          eds_service_name(), eds_service_name());
     }
-    auto watcher = MakeUnique<EndpointWatcher>(Ref());
+  }
+  // On the initial update, create the endpoint watcher.
+  if (is_initial_update) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
+      gpr_log(GPR_INFO, "[xdslb %p] starting watch for %s", this,
+              eds_service_name());
+    }
+    auto watcher = absl::make_unique<EndpointWatcher>(
+        Ref(DEBUG_LOCATION, "EndpointWatcher"));
     endpoint_watcher_ = watcher.get();
     xds_client()->WatchEndpointData(StringView(eds_service_name()),
                                     std::move(watcher));
-  }
-  // Update load reporting if needed.
-  // TODO(roth): Ideally, we should not collect any stats if load reporting
-  // is disabled, which would require changing this code to recreate
-  // all of the pickers whenever load reporting is enabled or disabled
-  // here.
-  if (is_initial_update ||
-      (config_->lrs_load_reporting_server_name() == nullptr) !=
-          (old_config->lrs_load_reporting_server_name() == nullptr) ||
-      (config_->lrs_load_reporting_server_name() != nullptr &&
-       old_config->lrs_load_reporting_server_name() != nullptr &&
-       strcmp(config_->lrs_load_reporting_server_name(),
-              old_config->lrs_load_reporting_server_name()) != 0)) {
-    if (old_config != nullptr &&
-        old_config->lrs_load_reporting_server_name() != nullptr) {
-      xds_client()->RemoveClientStats(
-          StringView(old_config->lrs_load_reporting_server_name()),
-          StringView(old_eds_service_name), &client_stats_);
-    }
-    if (config_->lrs_load_reporting_server_name() != nullptr) {
-      xds_client()->AddClientStats(
-          StringView(config_->lrs_load_reporting_server_name()),
-          StringView(eds_service_name()), &client_stats_);
-    }
+  } else {
+    // Update priority list.
+    // Note that this comes after updating drop_stats_, since we want that
+    // to be used by any new picker we create here.
+    // No need to do this on the initial update, since there won't be any
+    // priorities to update yet.
+    const bool update_locality_stats =
+        config_->lrs_load_reporting_server_name() !=
+        old_config->lrs_load_reporting_server_name();
+    UpdatePrioritiesLocked(update_locality_stats);
   }
 }
 
@@ -890,127 +845,37 @@ void XdsLb::OnFallbackTimerLocked(void* arg, grpc_error* error) {
 
 void XdsLb::UpdateFallbackPolicyLocked() {
   if (shutting_down_) return;
-  // Construct update args.
+  // Create policy if needed.
+  if (fallback_policy_ == nullptr) {
+    fallback_policy_ = CreateFallbackPolicyLocked(args_);
+    GPR_ASSERT(fallback_policy_ != nullptr);
+  }
+  // Perform update.
   UpdateArgs update_args;
   update_args.addresses = fallback_backend_addresses_;
   update_args.config = config_->fallback_policy();
   update_args.args = grpc_channel_args_copy(args_);
-  // If the child policy name changes, we need to create a new child
-  // policy.  When this happens, we leave child_policy_ as-is and store
-  // the new child policy in pending_child_policy_.  Once the new child
-  // policy transitions into state READY, we swap it into child_policy_,
-  // replacing the original child policy.  So pending_child_policy_ is
-  // non-null only between when we apply an update that changes the child
-  // policy name and when the new child reports state READY.
-  //
-  // Updates can arrive at any point during this transition.  We always
-  // apply updates relative to the most recently created child policy,
-  // even if the most recent one is still in pending_child_policy_.  This
-  // is true both when applying the updates to an existing child policy
-  // and when determining whether we need to create a new policy.
-  //
-  // As a result of this, there are several cases to consider here:
-  //
-  // 1. We have no existing child policy (i.e., we have started up but
-  //    have not yet received a serverlist from the balancer or gone
-  //    into fallback mode; in this case, both child_policy_ and
-  //    pending_child_policy_ are null).  In this case, we create a
-  //    new child policy and store it in child_policy_.
-  //
-  // 2. We have an existing child policy and have no pending child policy
-  //    from a previous update (i.e., either there has not been a
-  //    previous update that changed the policy name, or we have already
-  //    finished swapping in the new policy; in this case, child_policy_
-  //    is non-null but pending_child_policy_ is null).  In this case:
-  //    a. If child_policy_->name() equals child_policy_name, then we
-  //       update the existing child policy.
-  //    b. If child_policy_->name() does not equal child_policy_name,
-  //       we create a new policy.  The policy will be stored in
-  //       pending_child_policy_ and will later be swapped into
-  //       child_policy_ by the helper when the new child transitions
-  //       into state READY.
-  //
-  // 3. We have an existing child policy and have a pending child policy
-  //    from a previous update (i.e., a previous update set
-  //    pending_child_policy_ as per case 2b above and that policy has
-  //    not yet transitioned into state READY and been swapped into
-  //    child_policy_; in this case, both child_policy_ and
-  //    pending_child_policy_ are non-null).  In this case:
-  //    a. If pending_child_policy_->name() equals child_policy_name,
-  //       then we update the existing pending child policy.
-  //    b. If pending_child_policy->name() does not equal
-  //       child_policy_name, then we create a new policy.  The new
-  //       policy is stored in pending_child_policy_ (replacing the one
-  //       that was there before, which will be immediately shut down)
-  //       and will later be swapped into child_policy_ by the helper
-  //       when the new child transitions into state READY.
-  const char* fallback_policy_name = update_args.config == nullptr
-                                         ? "round_robin"
-                                         : update_args.config->name();
-  const bool create_policy =
-      // case 1
-      fallback_policy_ == nullptr ||
-      // case 2b
-      (pending_fallback_policy_ == nullptr &&
-       strcmp(fallback_policy_->name(), fallback_policy_name) != 0) ||
-      // case 3b
-      (pending_fallback_policy_ != nullptr &&
-       strcmp(pending_fallback_policy_->name(), fallback_policy_name) != 0);
-  LoadBalancingPolicy* policy_to_update = nullptr;
-  if (create_policy) {
-    // Cases 1, 2b, and 3b: create a new child policy.
-    // If child_policy_ is null, we set it (case 1), else we set
-    // pending_child_policy_ (cases 2b and 3b).
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
-      gpr_log(GPR_INFO, "[xdslb %p] Creating new %sfallback policy %s", this,
-              fallback_policy_ == nullptr ? "" : "pending ",
-              fallback_policy_name);
-    }
-    auto& lb_policy = fallback_policy_ == nullptr ? fallback_policy_
-                                                  : pending_fallback_policy_;
-    lb_policy =
-        CreateFallbackPolicyLocked(fallback_policy_name, update_args.args);
-    policy_to_update = lb_policy.get();
-  } else {
-    // Cases 2a and 3a: update an existing policy.
-    // If we have a pending child policy, send the update to the pending
-    // policy (case 3a), else send it to the current policy (case 2a).
-    policy_to_update = pending_fallback_policy_ != nullptr
-                           ? pending_fallback_policy_.get()
-                           : fallback_policy_.get();
-  }
-  GPR_ASSERT(policy_to_update != nullptr);
-  // Update the policy.
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
-    gpr_log(
-        GPR_INFO, "[xdslb %p] Updating %sfallback policy %p", this,
-        policy_to_update == pending_fallback_policy_.get() ? "pending " : "",
-        policy_to_update);
+    gpr_log(GPR_INFO, "[xdslb %p] Updating fallback child policy handler %p",
+            this, fallback_policy_.get());
   }
-  policy_to_update->UpdateLocked(std::move(update_args));
+  fallback_policy_->UpdateLocked(std::move(update_args));
 }
 
 OrphanablePtr<LoadBalancingPolicy> XdsLb::CreateFallbackPolicyLocked(
-    const char* name, const grpc_channel_args* args) {
-  FallbackHelper* helper =
-      new FallbackHelper(Ref(DEBUG_LOCATION, "FallbackHelper"));
+    const grpc_channel_args* args) {
   LoadBalancingPolicy::Args lb_policy_args;
   lb_policy_args.combiner = combiner();
   lb_policy_args.args = args;
   lb_policy_args.channel_control_helper =
-      std::unique_ptr<ChannelControlHelper>(helper);
+      absl::make_unique<FallbackHelper>(Ref(DEBUG_LOCATION, "FallbackHelper"));
   OrphanablePtr<LoadBalancingPolicy> lb_policy =
-      LoadBalancingPolicyRegistry::CreateLoadBalancingPolicy(
-          name, std::move(lb_policy_args));
-  if (GPR_UNLIKELY(lb_policy == nullptr)) {
-    gpr_log(GPR_ERROR, "[xdslb %p] Failure creating fallback policy %s", this,
-            name);
-    return nullptr;
-  }
-  helper->set_child(lb_policy.get());
+      MakeOrphanable<ChildPolicyHandler>(std::move(lb_policy_args),
+                                         &grpc_lb_xds_trace);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
-    gpr_log(GPR_INFO, "[xdslb %p] Created new fallback policy %s (%p)", this,
-            name, lb_policy.get());
+    gpr_log(GPR_INFO,
+            "[xdslb %p] Created new fallback child policy handler (%p)", this,
+            lb_policy.get());
   }
   // Add the xDS's interested_parties pollset_set to that of the newly created
   // child policy. This will make the child policy progress upon activity on xDS
@@ -1024,25 +889,25 @@ void XdsLb::MaybeExitFallbackMode() {
   if (fallback_policy_ == nullptr) return;
   gpr_log(GPR_INFO, "[xdslb %p] Exiting fallback mode", this);
   fallback_policy_.reset();
-  pending_fallback_policy_.reset();
 }
 
 //
-// XdsLb::PriorityList
+// priority list-related methods
 //
 
-void XdsLb::PriorityList::UpdateLocked() {
-  const auto& priority_list_update = xds_policy_->priority_list_update_;
+void XdsLb::UpdatePrioritiesLocked(bool update_locality_stats) {
   // 1. Remove from the priority list the priorities that are not in the update.
-  DeactivatePrioritiesLowerThan(priority_list_update.LowestPriority());
+  DeactivatePrioritiesLowerThan(priority_list_update_.LowestPriority());
   // 2. Update all the existing priorities.
   for (uint32_t priority = 0; priority < priorities_.size(); ++priority) {
     LocalityMap* locality_map = priorities_[priority].get();
-    const auto* locality_map_update = priority_list_update.Find(priority);
+    const auto* locality_map_update = priority_list_update_.Find(priority);
+    // If we have more current priorities than exist in the update, stop here.
+    if (locality_map_update == nullptr) break;
     // Propagate locality_map_update.
     // TODO(juanlishen): Find a clean way to skip duplicate update for a
     // priority.
-    locality_map->UpdateLocked(*locality_map_update);
+    locality_map->UpdateLocked(*locality_map_update, update_locality_stats);
   }
   // 3. Only create a new locality map if all the existing ones have failed.
   if (priorities_.empty() ||
@@ -1054,54 +919,62 @@ void XdsLb::PriorityList::UpdateLocked() {
     // to be created.
     MaybeCreateLocalityMapLocked(new_priority);
   }
-}
-
-void XdsLb::PriorityList::ResetBackoffLocked() {
-  for (size_t i = 0; i < priorities_.size(); ++i) {
-    priorities_[i]->ResetBackoffLocked();
+  // 4. If we updated locality stats and we already have at least one
+  // priority, update the picker to start using the new stats object(s).
+  if (update_locality_stats && !priorities_.empty()) {
+    UpdateXdsPickerLocked();
   }
 }
 
-void XdsLb::PriorityList::ShutdownLocked() { priorities_.clear(); }
-
-void XdsLb::PriorityList::UpdateXdsPickerLocked() {
+void XdsLb::UpdateXdsPickerLocked() {
   // If we are in fallback mode, don't generate an xds picker from localities.
-  if (xds_policy_->fallback_policy_ != nullptr) return;
-  if (current_priority() == UINT32_MAX) {
-    grpc_error* error = grpc_error_set_int(
-        GRPC_ERROR_CREATE_FROM_STATIC_STRING("no ready locality map"),
-        GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
-    xds_policy_->channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_TRANSIENT_FAILURE,
-        MakeUnique<TransientFailurePicker>(error));
+  if (fallback_policy_ != nullptr) return;
+  // If we're dropping all calls, report READY, even though we won't
+  // have a selected priority.
+  if (drop_config_ != nullptr && drop_config_->drop_all()) {
+    channel_control_helper()->UpdateState(
+        GRPC_CHANNEL_READY,
+        absl::make_unique<LocalityPicker>(this, LocalityPicker::PickerList{}));
+    return;
+  }
+  // If we don't have a selected priority, report TRANSIENT_FAILURE.
+  if (current_priority_ == UINT32_MAX) {
+    if (fallback_policy_ == nullptr) {
+      grpc_error* error = grpc_error_set_int(
+          GRPC_ERROR_CREATE_FROM_STATIC_STRING("no ready locality map"),
+          GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_UNAVAILABLE);
+      channel_control_helper()->UpdateState(
+          GRPC_CHANNEL_TRANSIENT_FAILURE,
+          absl::make_unique<TransientFailurePicker>(error));
+    }
     return;
   }
   priorities_[current_priority_]->UpdateXdsPickerLocked();
 }
 
-void XdsLb::PriorityList::MaybeCreateLocalityMapLocked(uint32_t priority) {
+void XdsLb::MaybeCreateLocalityMapLocked(uint32_t priority) {
   // Exhausted priorities in the update.
-  if (!priority_list_update().Contains(priority)) return;
-  auto new_locality_map = new LocalityMap(
-      xds_policy_->Ref(DEBUG_LOCATION, "XdsLb+LocalityMap"), priority);
+  if (!priority_list_update_.Contains(priority)) return;
+  auto new_locality_map =
+      new LocalityMap(Ref(DEBUG_LOCATION, "LocalityMap"), priority);
   priorities_.emplace_back(OrphanablePtr<LocalityMap>(new_locality_map));
-  new_locality_map->UpdateLocked(*priority_list_update().Find(priority));
+  new_locality_map->UpdateLocked(*priority_list_update_.Find(priority),
+                                 false /*update_locality_stats*/);
 }
 
-void XdsLb::PriorityList::FailoverOnConnectionFailureLocked() {
+void XdsLb::FailoverOnConnectionFailureLocked() {
   const uint32_t failed_priority = LowestPriority();
   // If we're failing over from the lowest priority, report TRANSIENT_FAILURE.
-  if (failed_priority == priority_list_update().LowestPriority()) {
+  if (failed_priority == priority_list_update_.LowestPriority()) {
     UpdateXdsPickerLocked();
   }
   MaybeCreateLocalityMapLocked(failed_priority + 1);
 }
 
-void XdsLb::PriorityList::FailoverOnDisconnectionLocked(
-    uint32_t failed_priority) {
+void XdsLb::FailoverOnDisconnectionLocked(uint32_t failed_priority) {
   current_priority_ = UINT32_MAX;
   for (uint32_t next_priority = failed_priority + 1;
-       next_priority <= priority_list_update().LowestPriority();
+       next_priority <= priority_list_update_.LowestPriority();
        ++next_priority) {
     if (!Contains(next_priority)) {
       MaybeCreateLocalityMapLocked(next_priority);
@@ -1111,17 +984,17 @@ void XdsLb::PriorityList::FailoverOnDisconnectionLocked(
   }
 }
 
-void XdsLb::PriorityList::SwitchToHigherPriorityLocked(uint32_t priority) {
+void XdsLb::SwitchToHigherPriorityLocked(uint32_t priority) {
   current_priority_ = priority;
   DeactivatePrioritiesLowerThan(current_priority_);
   UpdateXdsPickerLocked();
 }
 
-void XdsLb::PriorityList::DeactivatePrioritiesLowerThan(uint32_t priority) {
+void XdsLb::DeactivatePrioritiesLowerThan(uint32_t priority) {
   if (priorities_.empty()) return;
   // Deactivate the locality maps from the lowest priority.
   for (uint32_t p = LowestPriority(); p > priority; --p) {
-    if (xds_policy_->locality_retention_interval_ms_ == 0) {
+    if (locality_retention_interval_ms_ == 0) {
       priorities_.pop_back();
     } else {
       priorities_[p]->DeactivateLocked();
@@ -1129,30 +1002,37 @@ void XdsLb::PriorityList::DeactivatePrioritiesLowerThan(uint32_t priority) {
   }
 }
 
-OrphanablePtr<XdsLb::PriorityList::LocalityMap::Locality>
-XdsLb::PriorityList::ExtractLocalityLocked(
+OrphanablePtr<XdsLb::LocalityMap::Locality> XdsLb::ExtractLocalityLocked(
     const RefCountedPtr<XdsLocalityName>& name, uint32_t exclude_priority) {
   for (uint32_t priority = 0; priority < priorities_.size(); ++priority) {
     if (priority == exclude_priority) continue;
     LocalityMap* locality_map = priorities_[priority].get();
     auto locality = locality_map->ExtractLocalityLocked(name);
-    if (locality != nullptr) return locality;
+    if (locality != nullptr) {
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
+        gpr_log(GPR_INFO,
+                "[xdslb %p] moving locality %p %s to new priority (%" PRIu32
+                " -> %" PRIu32 ")",
+                this, locality.get(), name->AsHumanReadableString(),
+                exclude_priority, priority);
+      }
+      return locality;
+    }
   }
   return nullptr;
 }
 
 //
-// XdsLb::PriorityList::LocalityMap
+// XdsLb::LocalityMap
 //
 
-XdsLb::PriorityList::LocalityMap::LocalityMap(RefCountedPtr<XdsLb> xds_policy,
-                                              uint32_t priority)
+XdsLb::LocalityMap::LocalityMap(RefCountedPtr<XdsLb> xds_policy,
+                                uint32_t priority)
     : xds_policy_(std::move(xds_policy)), priority_(priority) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
     gpr_log(GPR_INFO, "[xdslb %p] Creating priority %" PRIu32,
             xds_policy_.get(), priority_);
   }
-
   GRPC_CLOSURE_INIT(&on_failover_timer_, OnFailoverTimer, this,
                     grpc_schedule_on_exec_ctx);
   // Start the failover timer.
@@ -1163,15 +1043,17 @@ XdsLb::PriorityList::LocalityMap::LocalityMap(RefCountedPtr<XdsLb> xds_policy,
       &on_failover_timer_);
   failover_timer_callback_pending_ = true;
   // This is the first locality map ever created, report CONNECTING.
-  if (priority_ == 0) {
+  if (priority_ == 0 && xds_policy_->fallback_policy_ == nullptr) {
     xds_policy_->channel_control_helper()->UpdateState(
-        GRPC_CHANNEL_CONNECTING, MakeUnique<QueuePicker>(xds_policy_->Ref(
-                                     DEBUG_LOCATION, "QueuePicker")));
+        GRPC_CHANNEL_CONNECTING,
+        absl::make_unique<QueuePicker>(
+            xds_policy_->Ref(DEBUG_LOCATION, "QueuePicker")));
   }
 }
 
-void XdsLb::PriorityList::LocalityMap::UpdateLocked(
-    const XdsPriorityListUpdate::LocalityMap& locality_map_update) {
+void XdsLb::LocalityMap::UpdateLocked(
+    const XdsApi::PriorityListUpdate::LocalityMap& priority_update,
+    bool update_locality_stats) {
   if (xds_policy_->shutting_down_) return;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
     gpr_log(GPR_INFO, "[xdslb %p] Start Updating priority %" PRIu32,
@@ -1180,11 +1062,11 @@ void XdsLb::PriorityList::LocalityMap::UpdateLocked(
   // Maybe reactivate the locality map in case all the active locality maps have
   // failed.
   MaybeReactivateLocked();
-  // Remove (later) the localities not in locality_map_update.
+  // Remove (later) the localities not in priority_update.
   for (auto iter = localities_.begin(); iter != localities_.end();) {
     const auto& name = iter->first;
     Locality* locality = iter->second.get();
-    if (locality_map_update.Contains(name)) {
+    if (priority_update.Contains(name)) {
       ++iter;
       continue;
     }
@@ -1195,14 +1077,14 @@ void XdsLb::PriorityList::LocalityMap::UpdateLocked(
       ++iter;
     }
   }
-  // Add or update the localities in locality_map_update.
-  for (const auto& p : locality_map_update.localities) {
+  // Add or update the localities in priority_update.
+  for (const auto& p : priority_update.localities) {
     const auto& name = p.first;
     const auto& locality_update = p.second;
     OrphanablePtr<Locality>& locality = localities_[name];
     if (locality == nullptr) {
       // Move from another locality map if possible.
-      locality = priority_list()->ExtractLocalityLocked(name, priority_);
+      locality = xds_policy_->ExtractLocalityLocked(name, priority_);
       if (locality != nullptr) {
         locality->set_locality_map(
             Ref(DEBUG_LOCATION, "LocalityMap+Locality_move"));
@@ -1214,38 +1096,74 @@ void XdsLb::PriorityList::LocalityMap::UpdateLocked(
     // Keep a copy of serverlist in the update so that we can compare it
     // with the future ones.
     locality->UpdateLocked(locality_update.lb_weight,
-                           locality_update.serverlist);
+                           locality_update.serverlist, update_locality_stats);
+  }
+  // If this is the current priority and we removed all of the READY
+  // localities, go into state CONNECTING.
+  // TODO(roth): Ideally, we should model this as a graceful policy
+  // switch: we should keep using the old localities for a short period
+  // of time, long enough to give the new localities a chance to get
+  // connected.  As part of refactoring this policy, we should try to
+  // fix that.
+  if (priority_ == xds_policy()->current_priority_) {
+    bool found_ready = false;
+    for (auto& p : localities_) {
+      const auto& locality_name = p.first;
+      Locality* locality = p.second.get();
+      if (!locality_map_update()->Contains(locality_name)) continue;
+      if (locality->connectivity_state() == GRPC_CHANNEL_READY) {
+        found_ready = true;
+        break;
+      }
+    }
+    if (!found_ready) {
+      xds_policy_->channel_control_helper()->UpdateState(
+          GRPC_CHANNEL_CONNECTING,
+          absl::make_unique<QueuePicker>(
+              xds_policy_->Ref(DEBUG_LOCATION, "QueuePicker")));
+      xds_policy_->current_priority_ = UINT32_MAX;
+    }
   }
 }
 
-void XdsLb::PriorityList::LocalityMap::ResetBackoffLocked() {
+void XdsLb::LocalityMap::ResetBackoffLocked() {
   for (auto& p : localities_) p.second->ResetBackoffLocked();
 }
 
-void XdsLb::PriorityList::LocalityMap::UpdateXdsPickerLocked() {
+void XdsLb::LocalityMap::UpdateXdsPickerLocked() {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
+    gpr_log(GPR_INFO, "[xdslb %p] constructing new picker", xds_policy());
+  }
   // Construct a new xds picker which maintains a map of all locality pickers
   // that are ready. Each locality is represented by a portion of the range
   // proportional to its weight, such that the total range is the sum of the
   // weights of all localities.
   LocalityPicker::PickerList picker_list;
   uint32_t end = 0;
-  for (const auto& p : localities_) {
+  for (auto& p : localities_) {
     const auto& locality_name = p.first;
-    const Locality* locality = p.second.get();
+    Locality* locality = p.second.get();
     // Skip the localities that are not in the latest locality map update.
-    if (!locality_map_update()->Contains(locality_name)) continue;
+    const auto* locality_update = locality_map_update();
+    if (locality_update == nullptr) continue;
+    if (!locality_update->Contains(locality_name)) continue;
     if (locality->connectivity_state() != GRPC_CHANNEL_READY) continue;
     end += locality->weight();
-    picker_list.push_back(std::make_pair(end, locality->picker_wrapper()));
+    picker_list.push_back(
+        std::make_pair(end, locality->GetLoadReportingPicker()));
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
+      gpr_log(GPR_INFO, "[xdslb %p]   locality=%s weight=%d picker=%p",
+              xds_policy(), locality_name->AsHumanReadableString(),
+              locality->weight(), picker_list.back().second.get());
+    }
   }
   xds_policy()->channel_control_helper()->UpdateState(
-      GRPC_CHANNEL_READY, MakeUnique<LocalityPicker>(
-                              xds_policy_->Ref(DEBUG_LOCATION, "XdsLb+Picker"),
-                              std::move(picker_list)));
+      GRPC_CHANNEL_READY,
+      absl::make_unique<LocalityPicker>(xds_policy(), std::move(picker_list)));
 }
 
-OrphanablePtr<XdsLb::PriorityList::LocalityMap::Locality>
-XdsLb::PriorityList::LocalityMap::ExtractLocalityLocked(
+OrphanablePtr<XdsLb::LocalityMap::Locality>
+XdsLb::LocalityMap::ExtractLocalityLocked(
     const RefCountedPtr<XdsLocalityName>& name) {
   for (auto iter = localities_.begin(); iter != localities_.end(); ++iter) {
     const auto& name_in_map = iter->first;
@@ -1258,7 +1176,11 @@ XdsLb::PriorityList::LocalityMap::ExtractLocalityLocked(
   return nullptr;
 }
 
-void XdsLb::PriorityList::LocalityMap::DeactivateLocked() {
+void XdsLb::LocalityMap::DeactivateLocked() {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
+    gpr_log(GPR_INFO, "[xdslb %p] deactivating priority %" PRIu32, xds_policy(),
+            priority_);
+  }
   // If already deactivated, don't do it again.
   if (delayed_removal_timer_callback_pending_) return;
   MaybeCancelFailoverTimerLocked();
@@ -1279,24 +1201,28 @@ void XdsLb::PriorityList::LocalityMap::DeactivateLocked() {
   delayed_removal_timer_callback_pending_ = true;
 }
 
-bool XdsLb::PriorityList::LocalityMap::MaybeReactivateLocked() {
+bool XdsLb::LocalityMap::MaybeReactivateLocked() {
   // Don't reactivate a priority that is not higher than the current one.
-  if (priority_ >= priority_list()->current_priority()) return false;
+  if (priority_ >= xds_policy_->current_priority_) return false;
   // Reactivate this priority by cancelling deletion timer.
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
+    gpr_log(GPR_INFO, "[xdslb %p] reactivating priority %" PRIu32, xds_policy(),
+            priority_);
+  }
   if (delayed_removal_timer_callback_pending_) {
     grpc_timer_cancel(&delayed_removal_timer_);
   }
   // Switch to this higher priority if it's READY.
   if (connectivity_state_ != GRPC_CHANNEL_READY) return false;
-  priority_list()->SwitchToHigherPriorityLocked(priority_);
+  xds_policy_->SwitchToHigherPriorityLocked(priority_);
   return true;
 }
 
-void XdsLb::PriorityList::LocalityMap::MaybeCancelFailoverTimerLocked() {
+void XdsLb::LocalityMap::MaybeCancelFailoverTimerLocked() {
   if (failover_timer_callback_pending_) grpc_timer_cancel(&failover_timer_);
 }
 
-void XdsLb::PriorityList::LocalityMap::Orphan() {
+void XdsLb::LocalityMap::Orphan() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
     gpr_log(GPR_INFO, "[xdslb %p] Priority %" PRIu32 " orphaned.", xds_policy(),
             priority_);
@@ -1309,11 +1235,11 @@ void XdsLb::PriorityList::LocalityMap::Orphan() {
   Unref(DEBUG_LOCATION, "LocalityMap+Orphan");
 }
 
-void XdsLb::PriorityList::LocalityMap::OnLocalityStateUpdateLocked() {
+void XdsLb::LocalityMap::OnLocalityStateUpdateLocked() {
   UpdateConnectivityStateLocked();
   // Ignore priorities not in priority_list_update.
   if (!priority_list_update().Contains(priority_)) return;
-  const uint32_t current_priority = priority_list()->current_priority();
+  const uint32_t current_priority = xds_policy_->current_priority_;
   // Ignore lower-than-current priorities.
   if (priority_ > current_priority) return;
   // Maybe update fallback state.
@@ -1327,13 +1253,13 @@ void XdsLb::PriorityList::LocalityMap::OnLocalityStateUpdateLocked() {
     if (connectivity_state_ == GRPC_CHANNEL_READY) {
       MaybeCancelFailoverTimerLocked();
       // If a higher-than-current priority becomes READY, switch to use it.
-      priority_list()->SwitchToHigherPriorityLocked(priority_);
+      xds_policy_->SwitchToHigherPriorityLocked(priority_);
     } else if (connectivity_state_ == GRPC_CHANNEL_TRANSIENT_FAILURE) {
       // If a higher-than-current priority becomes TRANSIENT_FAILURE, only
       // handle it if it's the priority that is still in failover timeout.
       if (failover_timer_callback_pending_) {
         MaybeCancelFailoverTimerLocked();
-        priority_list()->FailoverOnConnectionFailureLocked();
+        xds_policy_->FailoverOnConnectionFailureLocked();
       }
     }
     return;
@@ -1341,7 +1267,7 @@ void XdsLb::PriorityList::LocalityMap::OnLocalityStateUpdateLocked() {
   // Update is for current priority.
   if (connectivity_state_ != GRPC_CHANNEL_READY) {
     // Fail over if it's no longer READY.
-    priority_list()->FailoverOnDisconnectionLocked(priority_);
+    xds_policy_->FailoverOnDisconnectionLocked(priority_);
   }
   // At this point, one of the following things has happened to the current
   // priority.
@@ -1349,10 +1275,10 @@ void XdsLb::PriorityList::LocalityMap::OnLocalityStateUpdateLocked() {
   // 2. It changed to a lower priority due to failover.
   // 3. It became invalid because failover didn't yield a READY priority.
   // In any case, update the xds picker.
-  priority_list()->UpdateXdsPickerLocked();
+  xds_policy_->UpdateXdsPickerLocked();
 }
 
-void XdsLb::PriorityList::LocalityMap::UpdateConnectivityStateLocked() {
+void XdsLb::LocalityMap::UpdateConnectivityStateLocked() {
   size_t num_ready = 0;
   size_t num_connecting = 0;
   size_t num_idle = 0;
@@ -1400,8 +1326,7 @@ void XdsLb::PriorityList::LocalityMap::UpdateConnectivityStateLocked() {
   }
 }
 
-void XdsLb::PriorityList::LocalityMap::OnDelayedRemovalTimer(
-    void* arg, grpc_error* error) {
+void XdsLb::LocalityMap::OnDelayedRemovalTimer(void* arg, grpc_error* error) {
   LocalityMap* self = static_cast<LocalityMap*>(arg);
   self->xds_policy_->combiner()->Run(
       GRPC_CLOSURE_INIT(&self->on_delayed_removal_timer_,
@@ -1409,14 +1334,13 @@ void XdsLb::PriorityList::LocalityMap::OnDelayedRemovalTimer(
       GRPC_ERROR_REF(error));
 }
 
-void XdsLb::PriorityList::LocalityMap::OnDelayedRemovalTimerLocked(
-    void* arg, grpc_error* error) {
+void XdsLb::LocalityMap::OnDelayedRemovalTimerLocked(void* arg,
+                                                     grpc_error* error) {
   LocalityMap* self = static_cast<LocalityMap*>(arg);
   self->delayed_removal_timer_callback_pending_ = false;
   if (error == GRPC_ERROR_NONE && !self->xds_policy_->shutting_down_) {
-    auto* priority_list = self->priority_list();
     const bool keep = self->priority_list_update().Contains(self->priority_) &&
-                      self->priority_ <= priority_list->current_priority();
+                      self->priority_ <= self->xds_policy_->current_priority_;
     if (!keep) {
       // This check is to make sure we always delete the locality maps from
       // the lowest priority even if the closures of the back-to-back timers
@@ -1425,8 +1349,8 @@ void XdsLb::PriorityList::LocalityMap::OnDelayedRemovalTimerLocked(
       // deactivated locality maps when out-of-order closures are run.
       // TODO(juanlishen): Check the timer implementation to see if this
       // defense is necessary.
-      if (self->priority_ == priority_list->LowestPriority()) {
-        priority_list->priorities_.pop_back();
+      if (self->priority_ == self->xds_policy_->LowestPriority()) {
+        self->xds_policy_->priorities_.pop_back();
       } else {
         gpr_log(GPR_ERROR,
                 "[xdslb %p] Priority %" PRIu32
@@ -1439,8 +1363,7 @@ void XdsLb::PriorityList::LocalityMap::OnDelayedRemovalTimerLocked(
   self->Unref(DEBUG_LOCATION, "LocalityMap+timer");
 }
 
-void XdsLb::PriorityList::LocalityMap::OnFailoverTimer(void* arg,
-                                                       grpc_error* error) {
+void XdsLb::LocalityMap::OnFailoverTimer(void* arg, grpc_error* error) {
   LocalityMap* self = static_cast<LocalityMap*>(arg);
   self->xds_policy_->combiner()->Run(
       GRPC_CLOSURE_INIT(&self->on_failover_timer_, OnFailoverTimerLocked, self,
@@ -1448,31 +1371,31 @@ void XdsLb::PriorityList::LocalityMap::OnFailoverTimer(void* arg,
       GRPC_ERROR_REF(error));
 }
 
-void XdsLb::PriorityList::LocalityMap::OnFailoverTimerLocked(
-    void* arg, grpc_error* error) {
+void XdsLb::LocalityMap::OnFailoverTimerLocked(void* arg, grpc_error* error) {
   LocalityMap* self = static_cast<LocalityMap*>(arg);
   self->failover_timer_callback_pending_ = false;
   if (error == GRPC_ERROR_NONE && !self->xds_policy_->shutting_down_) {
-    self->priority_list()->FailoverOnConnectionFailureLocked();
+    self->xds_policy_->FailoverOnConnectionFailureLocked();
   }
   self->Unref(DEBUG_LOCATION, "LocalityMap+OnFailoverTimerLocked");
 }
 
 //
-// XdsLb::PriorityList::LocalityMap::Locality
+// XdsLb::LocalityMap::Locality
 //
 
-XdsLb::PriorityList::LocalityMap::Locality::Locality(
-    RefCountedPtr<LocalityMap> locality_map,
-    RefCountedPtr<XdsLocalityName> name)
+XdsLb::LocalityMap::Locality::Locality(RefCountedPtr<LocalityMap> locality_map,
+                                       RefCountedPtr<XdsLocalityName> name)
     : locality_map_(std::move(locality_map)), name_(std::move(name)) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
     gpr_log(GPR_INFO, "[xdslb %p] created Locality %p for %s", xds_policy(),
             this, name_->AsHumanReadableString());
   }
+  // Initialize locality stats if load reporting is enabled.
+  UpdateLocalityStats();
 }
 
-XdsLb::PriorityList::LocalityMap::Locality::~Locality() {
+XdsLb::LocalityMap::Locality::~Locality() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
     gpr_log(GPR_INFO, "[xdslb %p] Locality %p %s: destroying locality",
             xds_policy(), this, name_->AsHumanReadableString());
@@ -1480,8 +1403,20 @@ XdsLb::PriorityList::LocalityMap::Locality::~Locality() {
   locality_map_.reset(DEBUG_LOCATION, "Locality");
 }
 
-grpc_channel_args*
-XdsLb::PriorityList::LocalityMap::Locality::CreateChildPolicyArgsLocked(
+void XdsLb::LocalityMap::Locality::UpdateLocalityStats() {
+  stats_.reset();
+  if (xds_policy()->config_->lrs_load_reporting_server_name().has_value()) {
+    stats_ = xds_policy()->xds_client()->AddClusterLocalityStats(
+        xds_policy()->config_->lrs_load_reporting_server_name().value(),
+        // TODO(roth): We currently hard-code the assumption that
+        // cluster name and EDS service name are the same.  Fix this
+        // as part of refectoring this LB policy.
+        xds_policy()->eds_service_name(), xds_policy()->eds_service_name(),
+        name_);
+  }
+}
+
+grpc_channel_args* XdsLb::LocalityMap::Locality::CreateChildPolicyArgsLocked(
     const grpc_channel_args* args_in) {
   const grpc_arg args_to_add[] = {
       // A channel arg indicating if the target is a backend inferred from a
@@ -1499,28 +1434,20 @@ XdsLb::PriorityList::LocalityMap::Locality::CreateChildPolicyArgsLocked(
 }
 
 OrphanablePtr<LoadBalancingPolicy>
-XdsLb::PriorityList::LocalityMap::Locality::CreateChildPolicyLocked(
-    const char* name, const grpc_channel_args* args) {
-  Helper* helper = new Helper(this->Ref(DEBUG_LOCATION, "Helper"));
+XdsLb::LocalityMap::Locality::CreateChildPolicyLocked(
+    const grpc_channel_args* args) {
   LoadBalancingPolicy::Args lb_policy_args;
   lb_policy_args.combiner = xds_policy()->combiner();
   lb_policy_args.args = args;
   lb_policy_args.channel_control_helper =
-      std::unique_ptr<ChannelControlHelper>(helper);
+      absl::make_unique<Helper>(this->Ref(DEBUG_LOCATION, "Helper"));
   OrphanablePtr<LoadBalancingPolicy> lb_policy =
-      LoadBalancingPolicyRegistry::CreateLoadBalancingPolicy(
-          name, std::move(lb_policy_args));
-  if (GPR_UNLIKELY(lb_policy == nullptr)) {
-    gpr_log(GPR_ERROR,
-            "[xdslb %p] Locality %p %s: failure creating child policy %s",
-            xds_policy(), this, name_->AsHumanReadableString(), name);
-    return nullptr;
-  }
-  helper->set_child(lb_policy.get());
+      MakeOrphanable<ChildPolicyHandler>(std::move(lb_policy_args),
+                                         &grpc_lb_xds_trace);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
     gpr_log(GPR_INFO,
-            "[xdslb %p] Locality %p %s: Created new child policy %s (%p)",
-            xds_policy(), this, name_->AsHumanReadableString(), name,
+            "[xdslb %p] Locality %p %s: Created new child policy handler (%p)",
+            xds_policy(), this, name_->AsHumanReadableString(),
             lb_policy.get());
   }
   // Add the xDS's interested_parties pollset_set to that of the newly created
@@ -1531,134 +1458,55 @@ XdsLb::PriorityList::LocalityMap::Locality::CreateChildPolicyLocked(
   return lb_policy;
 }
 
-void XdsLb::PriorityList::LocalityMap::Locality::UpdateLocked(
-    uint32_t locality_weight, ServerAddressList serverlist) {
+void XdsLb::LocalityMap::Locality::UpdateLocked(uint32_t locality_weight,
+                                                ServerAddressList serverlist,
+                                                bool update_locality_stats) {
   if (xds_policy()->shutting_down_) return;
   // Update locality weight.
   weight_ = locality_weight;
   if (delayed_removal_timer_callback_pending_) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
+      gpr_log(GPR_INFO, "[xdslb %p] Locality %p %s: reactivating", xds_policy(),
+              this, name_->AsHumanReadableString());
+    }
     grpc_timer_cancel(&delayed_removal_timer_);
   }
+  // Update locality stats.
+  if (update_locality_stats) UpdateLocalityStats();
   // Construct update args.
   UpdateArgs update_args;
   update_args.addresses = std::move(serverlist);
   update_args.config = xds_policy()->config_->child_policy();
   update_args.args = CreateChildPolicyArgsLocked(xds_policy()->args_);
-  // If the child policy name changes, we need to create a new child
-  // policy.  When this happens, we leave child_policy_ as-is and store
-  // the new child policy in pending_child_policy_.  Once the new child
-  // policy transitions into state READY, we swap it into child_policy_,
-  // replacing the original child policy.  So pending_child_policy_ is
-  // non-null only between when we apply an update that changes the child
-  // policy name and when the new child reports state READY.
-  //
-  // Updates can arrive at any point during this transition.  We always
-  // apply updates relative to the most recently created child policy,
-  // even if the most recent one is still in pending_child_policy_.  This
-  // is true both when applying the updates to an existing child policy
-  // and when determining whether we need to create a new policy.
-  //
-  // As a result of this, there are several cases to consider here:
-  //
-  // 1. We have no existing child policy (i.e., we have started up but
-  //    have not yet received a serverlist from the balancer or gone
-  //    into fallback mode; in this case, both child_policy_ and
-  //    pending_child_policy_ are null).  In this case, we create a
-  //    new child policy and store it in child_policy_.
-  //
-  // 2. We have an existing child policy and have no pending child policy
-  //    from a previous update (i.e., either there has not been a
-  //    previous update that changed the policy name, or we have already
-  //    finished swapping in the new policy; in this case, child_policy_
-  //    is non-null but pending_child_policy_ is null).  In this case:
-  //    a. If child_policy_->name() equals child_policy_name, then we
-  //       update the existing child policy.
-  //    b. If child_policy_->name() does not equal child_policy_name,
-  //       we create a new policy.  The policy will be stored in
-  //       pending_child_policy_ and will later be swapped into
-  //       child_policy_ by the helper when the new child transitions
-  //       into state READY.
-  //
-  // 3. We have an existing child policy and have a pending child policy
-  //    from a previous update (i.e., a previous update set
-  //    pending_child_policy_ as per case 2b above and that policy has
-  //    not yet transitioned into state READY and been swapped into
-  //    child_policy_; in this case, both child_policy_ and
-  //    pending_child_policy_ are non-null).  In this case:
-  //    a. If pending_child_policy_->name() equals child_policy_name,
-  //       then we update the existing pending child policy.
-  //    b. If pending_child_policy->name() does not equal
-  //       child_policy_name, then we create a new policy.  The new
-  //       policy is stored in pending_child_policy_ (replacing the one
-  //       that was there before, which will be immediately shut down)
-  //       and will later be swapped into child_policy_ by the helper
-  //       when the new child transitions into state READY.
-  // TODO(juanlishen): If the child policy is not configured via service config,
-  // use whatever algorithm is specified by the balancer.
-  const char* child_policy_name = update_args.config == nullptr
-                                      ? "round_robin"
-                                      : update_args.config->name();
-  const bool create_policy =
-      // case 1
-      child_policy_ == nullptr ||
-      // case 2b
-      (pending_child_policy_ == nullptr &&
-       strcmp(child_policy_->name(), child_policy_name) != 0) ||
-      // case 3b
-      (pending_child_policy_ != nullptr &&
-       strcmp(pending_child_policy_->name(), child_policy_name) != 0);
-  LoadBalancingPolicy* policy_to_update = nullptr;
-  if (create_policy) {
-    // Cases 1, 2b, and 3b: create a new child policy.
-    // If child_policy_ is null, we set it (case 1), else we set
-    // pending_child_policy_ (cases 2b and 3b).
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
-      gpr_log(GPR_INFO,
-              "[xdslb %p] Locality %p %s: Creating new %schild policy %s",
-              xds_policy(), this, name_->AsHumanReadableString(),
-              child_policy_ == nullptr ? "" : "pending ", child_policy_name);
-    }
-    auto& lb_policy =
-        child_policy_ == nullptr ? child_policy_ : pending_child_policy_;
-    lb_policy = CreateChildPolicyLocked(child_policy_name, update_args.args);
-    policy_to_update = lb_policy.get();
-  } else {
-    // Cases 2a and 3a: update an existing policy.
-    // If we have a pending child policy, send the update to the pending
-    // policy (case 3a), else send it to the current policy (case 2a).
-    policy_to_update = pending_child_policy_ != nullptr
-                           ? pending_child_policy_.get()
-                           : child_policy_.get();
-  }
-  GPR_ASSERT(policy_to_update != nullptr);
+  // Create child policy if needed.
+  if (child_policy_ == nullptr) {
+    child_policy_ = CreateChildPolicyLocked(update_args.args);
+    GPR_ASSERT(child_policy_ != nullptr);
+  }
   // Update the policy.
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
-    gpr_log(GPR_INFO, "[xdslb %p] Locality %p %s: Updating %schild policy %p",
+    gpr_log(GPR_INFO,
+            "[xdslb %p] Locality %p %s: Updating child policy handler %p",
             xds_policy(), this, name_->AsHumanReadableString(),
-            policy_to_update == pending_child_policy_.get() ? "pending " : "",
-            policy_to_update);
+            child_policy_.get());
   }
-  policy_to_update->UpdateLocked(std::move(update_args));
+  child_policy_->UpdateLocked(std::move(update_args));
 }
 
-void XdsLb::PriorityList::LocalityMap::Locality::ShutdownLocked() {
+void XdsLb::LocalityMap::Locality::ShutdownLocked() {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
     gpr_log(GPR_INFO, "[xdslb %p] Locality %p %s: shutting down locality",
             xds_policy(), this, name_->AsHumanReadableString());
   }
+  stats_.reset();
   // Remove the child policy's interested_parties pollset_set from the
   // xDS policy.
   grpc_pollset_set_del_pollset_set(child_policy_->interested_parties(),
                                    xds_policy()->interested_parties());
   child_policy_.reset();
-  if (pending_child_policy_ != nullptr) {
-    grpc_pollset_set_del_pollset_set(
-        pending_child_policy_->interested_parties(),
-        xds_policy()->interested_parties());
-    pending_child_policy_.reset();
-  }
   // Drop our ref to the child's picker, in case it's holding a ref to
   // the child.
+  load_reporting_picker_.reset();
   picker_wrapper_.reset();
   if (delayed_removal_timer_callback_pending_) {
     grpc_timer_cancel(&delayed_removal_timer_);
@@ -1666,21 +1514,22 @@ void XdsLb::PriorityList::LocalityMap::Locality::ShutdownLocked() {
   shutdown_ = true;
 }
 
-void XdsLb::PriorityList::LocalityMap::Locality::ResetBackoffLocked() {
+void XdsLb::LocalityMap::Locality::ResetBackoffLocked() {
   child_policy_->ResetBackoffLocked();
-  if (pending_child_policy_ != nullptr) {
-    pending_child_policy_->ResetBackoffLocked();
-  }
 }
 
-void XdsLb::PriorityList::LocalityMap::Locality::Orphan() {
+void XdsLb::LocalityMap::Locality::Orphan() {
   ShutdownLocked();
   Unref();
 }
 
-void XdsLb::PriorityList::LocalityMap::Locality::DeactivateLocked() {
+void XdsLb::LocalityMap::Locality::DeactivateLocked() {
   // If already deactivated, don't do that again.
   if (weight_ == 0) return;
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
+    gpr_log(GPR_INFO, "[xdslb %p] Locality %p %s: deactivating", xds_policy(),
+            this, name_->AsHumanReadableString());
+  }
   // Set the locality weight to 0 so that future xds picker won't contain this
   // locality.
   weight_ = 0;
@@ -1695,8 +1544,8 @@ void XdsLb::PriorityList::LocalityMap::Locality::DeactivateLocked() {
   delayed_removal_timer_callback_pending_ = true;
 }
 
-void XdsLb::PriorityList::LocalityMap::Locality::OnDelayedRemovalTimer(
-    void* arg, grpc_error* error) {
+void XdsLb::LocalityMap::Locality::OnDelayedRemovalTimer(void* arg,
+                                                         grpc_error* error) {
   Locality* self = static_cast<Locality*>(arg);
   self->xds_policy()->combiner()->Run(
       GRPC_CLOSURE_INIT(&self->on_delayed_removal_timer_,
@@ -1704,7 +1553,7 @@ void XdsLb::PriorityList::LocalityMap::Locality::OnDelayedRemovalTimer(
       GRPC_ERROR_REF(error));
 }
 
-void XdsLb::PriorityList::LocalityMap::Locality::OnDelayedRemovalTimerLocked(
+void XdsLb::LocalityMap::Locality::OnDelayedRemovalTimerLocked(
     void* arg, grpc_error* error) {
   Locality* self = static_cast<Locality*>(arg);
   self->delayed_removal_timer_callback_pending_ = false;
@@ -1715,74 +1564,37 @@ void XdsLb::PriorityList::LocalityMap::Locality::OnDelayedRemovalTimerLocked(
 }
 
 //
-// XdsLb::Locality::Helper
+// XdsLb::LocalityMap::Locality::Helper
 //
 
-bool XdsLb::PriorityList::LocalityMap::Locality::Helper::CalledByPendingChild()
-    const {
-  GPR_ASSERT(child_ != nullptr);
-  return child_ == locality_->pending_child_policy_.get();
-}
-
-bool XdsLb::PriorityList::LocalityMap::Locality::Helper::CalledByCurrentChild()
-    const {
-  GPR_ASSERT(child_ != nullptr);
-  return child_ == locality_->child_policy_.get();
-}
-
 RefCountedPtr<SubchannelInterface>
-XdsLb::PriorityList::LocalityMap::Locality::Helper::CreateSubchannel(
+XdsLb::LocalityMap::Locality::Helper::CreateSubchannel(
     const grpc_channel_args& args) {
-  if (locality_->xds_policy()->shutting_down_ ||
-      (!CalledByPendingChild() && !CalledByCurrentChild())) {
-    return nullptr;
-  }
+  if (locality_->xds_policy()->shutting_down_) return nullptr;
   return locality_->xds_policy()->channel_control_helper()->CreateSubchannel(
       args);
 }
 
-void XdsLb::PriorityList::LocalityMap::Locality::Helper::UpdateState(
+void XdsLb::LocalityMap::Locality::Helper::UpdateState(
     grpc_connectivity_state state, std::unique_ptr<SubchannelPicker> picker) {
   if (locality_->xds_policy()->shutting_down_) return;
-  // If this request is from the pending child policy, ignore it until
-  // it reports READY, at which point we swap it into place.
-  if (CalledByPendingChild()) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
-      gpr_log(GPR_INFO,
-              "[xdslb %p helper %p] pending child policy %p reports state=%s",
-              locality_->xds_policy(), this,
-              locality_->pending_child_policy_.get(),
-              ConnectivityStateName(state));
-    }
-    if (state != GRPC_CHANNEL_READY) return;
-    grpc_pollset_set_del_pollset_set(
-        locality_->child_policy_->interested_parties(),
-        locality_->xds_policy()->interested_parties());
-    locality_->child_policy_ = std::move(locality_->pending_child_policy_);
-  } else if (!CalledByCurrentChild()) {
-    // This request is from an outdated child, so ignore it.
-    return;
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_xds_trace)) {
+    gpr_log(GPR_INFO,
+            "[xdslb %p helper %p] child policy handler %p reports state=%s",
+            locality_->xds_policy(), this, locality_->child_policy_.get(),
+            ConnectivityStateName(state));
   }
-  // Cache the picker and its state in the locality.
-  // TODO(roth): If load reporting is not configured, we should ideally
-  // pass a null LocalityStats ref to the EndpointPickerWrapper and have it
-  // not collect any stats, since they're not going to be used.  This would
-  // require recreating all of the pickers whenever we get a config update.
-  locality_->picker_wrapper_ = MakeRefCounted<EndpointPickerWrapper>(
-      std::move(picker),
-      locality_->xds_policy()->client_stats_.FindLocalityStats(
-          locality_->name_));
+  // Cache the state and picker in the locality.
   locality_->connectivity_state_ = state;
+  locality_->picker_wrapper_ =
+      MakeRefCounted<RefCountedEndpointPicker>(std::move(picker));
   // Notify the locality map.
   locality_->locality_map_->OnLocalityStateUpdateLocked();
 }
 
-void XdsLb::PriorityList::LocalityMap::Locality::Helper::AddTraceEvent(
-    TraceSeverity severity, StringView message) {
-  if (locality_->xds_policy()->shutting_down_ ||
-      (!CalledByPendingChild() && !CalledByCurrentChild())) {
-    return;
-  }
+void XdsLb::LocalityMap::Locality::Helper::AddTraceEvent(TraceSeverity severity,
+                                                         StringView message) {
+  if (locality_->xds_policy()->shutting_down_) return;
   locality_->xds_policy()->channel_control_helper()->AddTraceEvent(severity,
                                                                    message);
 }
@@ -1795,15 +1607,15 @@ class XdsFactory : public LoadBalancingPolicyFactory {
  public:
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
       LoadBalancingPolicy::Args args) const override {
-    return MakeOrphanable<XdsLb>(std::move(args));
+    return MakeOrphanable<XdsChildHandler>(std::move(args), &grpc_lb_xds_trace);
   }
 
   const char* name() const override { return kXds; }
 
   RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
-      const grpc_json* json, grpc_error** error) const override {
+      const Json& json, grpc_error** error) const override {
     GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
-    if (json == nullptr) {
+    if (json.type() == Json::Type::JSON_NULL) {
       // xds was mentioned as a policy in the deprecated loadBalancingPolicy
       // field or in the client API.
       *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
@@ -1811,74 +1623,118 @@ class XdsFactory : public LoadBalancingPolicyFactory {
           "Please use loadBalancingConfig field of service config instead.");
       return nullptr;
     }
-    GPR_DEBUG_ASSERT(strcmp(json->key, name()) == 0);
-    InlinedVector<grpc_error*, 3> error_list;
-    RefCountedPtr<LoadBalancingPolicy::Config> child_policy;
-    RefCountedPtr<LoadBalancingPolicy::Config> fallback_policy;
+    std::vector<grpc_error*> error_list;
+    // Child policy.
+    Json json_tmp;
+    const Json* child_policy_json;
+    auto it = json.object_value().find("childPolicy");
+    if (it == json.object_value().end()) {
+      json_tmp = Json::Array{Json::Object{
+          {"round_robin", Json::Object()},
+      }};
+      child_policy_json = &json_tmp;
+    } else {
+      child_policy_json = &it->second;
+    }
+    grpc_error* parse_error = GRPC_ERROR_NONE;
+    RefCountedPtr<LoadBalancingPolicy::Config> child_policy =
+        LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
+            *child_policy_json, &parse_error);
+    if (child_policy == nullptr) {
+      GPR_DEBUG_ASSERT(parse_error != GRPC_ERROR_NONE);
+      std::vector<grpc_error*> child_errors;
+      child_errors.push_back(parse_error);
+      error_list.push_back(
+          GRPC_ERROR_CREATE_FROM_VECTOR("field:childPolicy", &child_errors));
+    }
+    // Fallback policy.
+    const Json* fallback_policy_json;
+    it = json.object_value().find("fallbackPolicy");
+    if (it == json.object_value().end()) {
+      json_tmp = Json::Array{Json::Object{
+          {"round_robin", Json::Object()},
+      }};
+      fallback_policy_json = &json_tmp;
+    } else {
+      fallback_policy_json = &it->second;
+    }
+    RefCountedPtr<LoadBalancingPolicy::Config> fallback_policy =
+        LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
+            *fallback_policy_json, &parse_error);
+    if (fallback_policy == nullptr) {
+      GPR_DEBUG_ASSERT(parse_error != GRPC_ERROR_NONE);
+      std::vector<grpc_error*> child_errors;
+      child_errors.push_back(parse_error);
+      error_list.push_back(
+          GRPC_ERROR_CREATE_FROM_VECTOR("field:fallbackPolicy", &child_errors));
+    }
+    // EDS service name.
     const char* eds_service_name = nullptr;
+    it = json.object_value().find("edsServiceName");
+    if (it != json.object_value().end()) {
+      if (it->second.type() != Json::Type::STRING) {
+        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "field:edsServiceName error:type should be string"));
+      } else {
+        eds_service_name = it->second.string_value().c_str();
+      }
+    }
+    // LRS load reporting server name.
     const char* lrs_load_reporting_server_name = nullptr;
-    for (const grpc_json* field = json->child; field != nullptr;
-         field = field->next) {
-      if (field->key == nullptr) continue;
-      if (strcmp(field->key, "childPolicy") == 0) {
-        if (child_policy != nullptr) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:childPolicy error:Duplicate entry"));
-        }
-        grpc_error* parse_error = GRPC_ERROR_NONE;
-        child_policy = LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
-            field, &parse_error);
-        if (child_policy == nullptr) {
-          GPR_DEBUG_ASSERT(parse_error != GRPC_ERROR_NONE);
-          error_list.push_back(parse_error);
-        }
-      } else if (strcmp(field->key, "fallbackPolicy") == 0) {
-        if (fallback_policy != nullptr) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:fallbackPolicy error:Duplicate entry"));
-        }
-        grpc_error* parse_error = GRPC_ERROR_NONE;
-        fallback_policy = LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
-            field, &parse_error);
-        if (fallback_policy == nullptr) {
-          GPR_DEBUG_ASSERT(parse_error != GRPC_ERROR_NONE);
-          error_list.push_back(parse_error);
-        }
-      } else if (strcmp(field->key, "edsServiceName") == 0) {
-        if (eds_service_name != nullptr) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:edsServiceName error:Duplicate entry"));
-        }
-        if (field->type != GRPC_JSON_STRING) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:edsServiceName error:type should be string"));
-          continue;
-        }
-        eds_service_name = field->value;
-      } else if (strcmp(field->key, "lrsLoadReportingServerName") == 0) {
-        if (lrs_load_reporting_server_name != nullptr) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:lrsLoadReportingServerName error:Duplicate entry"));
-        }
-        if (field->type != GRPC_JSON_STRING) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "field:lrsLoadReportingServerName error:type should be string"));
-          continue;
-        }
-        lrs_load_reporting_server_name = field->value;
+    it = json.object_value().find("lrsLoadReportingServerName");
+    if (it != json.object_value().end()) {
+      if (it->second.type() != Json::Type::STRING) {
+        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "field:lrsLoadReportingServerName error:type should be string"));
+      } else {
+        lrs_load_reporting_server_name = it->second.string_value().c_str();
       }
     }
     if (error_list.empty()) {
-      return MakeRefCounted<ParsedXdsConfig>(
+      absl::optional<std::string> optional_lrs_load_reporting_server_name;
+      if (lrs_load_reporting_server_name != nullptr) {
+        optional_lrs_load_reporting_server_name.emplace(
+            std::string(lrs_load_reporting_server_name));
+      }
+      return MakeRefCounted<XdsConfig>(
           std::move(child_policy), std::move(fallback_policy),
-          grpc_core::UniquePtr<char>(gpr_strdup(eds_service_name)),
-          grpc_core::UniquePtr<char>(
-              gpr_strdup(lrs_load_reporting_server_name)));
+          eds_service_name == nullptr ? "" : eds_service_name,
+          std::move(optional_lrs_load_reporting_server_name));
     } else {
       *error = GRPC_ERROR_CREATE_FROM_VECTOR("Xds Parser", &error_list);
       return nullptr;
     }
   }
+
+ private:
+  class XdsChildHandler : public ChildPolicyHandler {
+   public:
+    XdsChildHandler(Args args, TraceFlag* tracer)
+        : ChildPolicyHandler(std::move(args), tracer) {}
+
+    bool ConfigChangeRequiresNewPolicyInstance(
+        LoadBalancingPolicy::Config* old_config,
+        LoadBalancingPolicy::Config* new_config) const override {
+      GPR_ASSERT(old_config->name() == kXds);
+      GPR_ASSERT(new_config->name() == kXds);
+      XdsConfig* old_xds_config = static_cast<XdsConfig*>(old_config);
+      XdsConfig* new_xds_config = static_cast<XdsConfig*>(new_config);
+      const char* old_eds_service_name =
+          old_xds_config->eds_service_name() == nullptr
+              ? ""
+              : old_xds_config->eds_service_name();
+      const char* new_eds_service_name =
+          new_xds_config->eds_service_name() == nullptr
+              ? ""
+              : new_xds_config->eds_service_name();
+      return strcmp(old_eds_service_name, new_eds_service_name) != 0;
+    }
+
+    OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
+        const char* name, LoadBalancingPolicy::Args args) const override {
+      return MakeOrphanable<XdsLb>(std::move(args));
+    }
+  };
 };
 
 }  // namespace
@@ -1892,7 +1748,7 @@ class XdsFactory : public LoadBalancingPolicyFactory {
 void grpc_lb_policy_xds_init() {
   grpc_core::LoadBalancingPolicyRegistry::Builder::
       RegisterLoadBalancingPolicyFactory(
-          grpc_core::MakeUnique<grpc_core::XdsFactory>());
+          absl::make_unique<grpc_core::XdsFactory>());
 }
 
 void grpc_lb_policy_xds_shutdown() {}