grpc 1.42.0 → 1.52.0

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

@@ -22,55 +22,84 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <inttypes.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include <algorithm>
 #include <deque>
-#include <functional>
 #include <list>
 #include <map>
+#include <memory>
+#include <random>
+#include <set>
 #include <string>
+#include <type_traits>
 #include <unordered_map>
 #include <utility>
+#include <vector>
 
-#include "absl/container/inlined_vector.h"
+#include "absl/base/thread_annotations.h"
 #include "absl/hash/hash.h"
-#include "absl/memory/memory.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
+#include "absl/types/optional.h"
+#include "upb/upb.h"
 #include "upb/upb.hpp"
 
-#include <grpc/grpc_security.h>
-#include <grpc/impl/codegen/byte_buffer_reader.h>
-#include <grpc/impl/codegen/grpc_types.h>
-#include <grpc/support/time.h>
+#include <grpc/byte_buffer.h>
+#include <grpc/byte_buffer_reader.h>
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/grpc.h>
+#include <grpc/impl/connectivity_state.h>
+#include <grpc/impl/propagation_bits.h>
+#include <grpc/slice.h>
+#include <grpc/status.h>
+#include <grpc/support/log.h>
 
 #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_factory.h"
-#include "src/core/ext/filters/client_channel/lb_policy_registry.h"
-#include "src/core/ext/filters/client_channel/resolver_registry.h"
 #include "src/core/lib/backoff/backoff.h"
-#include "src/core/lib/gpr/env.h"
-#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channelz.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/validation_errors.h"
+#include "src/core/lib/gprpp/work_serializer.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/json/json.h"
-#include "src/core/lib/json/json_util.h"
+#include "src/core/lib/json/json_args.h"
+#include "src/core/lib/json/json_object_loader.h"
+#include "src/core/lib/load_balancing/lb_policy.h"
+#include "src/core/lib/load_balancing/lb_policy_factory.h"
+#include "src/core/lib/load_balancing/lb_policy_registry.h"
+#include "src/core/lib/load_balancing/subchannel_interface.h"
+#include "src/core/lib/resolver/resolver_registry.h"
+#include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/security/credentials/credentials.h"
 #include "src/core/lib/security/credentials/fake/fake_credentials.h"
+#include "src/core/lib/service_config/service_config_impl.h"
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/error_utils.h"
-#include "src/core/lib/transport/static_metadata.h"
 #include "src/core/lib/uri/uri_parser.h"
 #include "src/proto/grpc/lookup/v1/rls.upb.h"
 
@@ -80,23 +109,25 @@ TraceFlag grpc_lb_rls_trace(false, "rls_lb");
 
 namespace {
 
-const char* kRls = "rls";
+using ::grpc_event_engine::experimental::EventEngine;
+
+constexpr absl::string_view kRls = "rls_experimental";
 const char kGrpc[] = "grpc";
 const char* kRlsRequestPath = "/grpc.lookup.v1.RouteLookupService/RouteLookup";
 const char* kFakeTargetFieldValue = "fake_target_field_value";
 const char* kRlsHeaderKey = "X-Google-RLS-Data";
 
-const grpc_millis kDefaultLookupServiceTimeout = 10000;
-const grpc_millis kMaxMaxAge = 5 * 60 * GPR_MS_PER_SEC;
-const grpc_millis kMinExpirationTime = 5 * GPR_MS_PER_SEC;
-const grpc_millis kCacheBackoffInitial = 1 * GPR_MS_PER_SEC;
+const Duration kDefaultLookupServiceTimeout = Duration::Seconds(10);
+const Duration kMaxMaxAge = Duration::Minutes(5);
+const Duration kMinExpirationTime = Duration::Seconds(5);
+const Duration kCacheBackoffInitial = Duration::Seconds(1);
 const double kCacheBackoffMultiplier = 1.6;
 const double kCacheBackoffJitter = 0.2;
-const grpc_millis kCacheBackoffMax = 120 * GPR_MS_PER_SEC;
-const grpc_millis kDefaultThrottleWindowSize = 30 * GPR_MS_PER_SEC;
+const Duration kCacheBackoffMax = Duration::Minutes(2);
+const Duration kDefaultThrottleWindowSize = Duration::Seconds(30);
 const double kDefaultThrottleRatioForSuccesses = 2.0;
-const int kDefaultThrottlePaddings = 8;
-const grpc_millis kCacheCleanupTimerInterval = 60 * GPR_MS_PER_SEC;
+const int kDefaultThrottlePadding = 8;
+const Duration kCacheCleanupTimerInterval = Duration::Minutes(1);
 const int64_t kMaxCacheSizeBytes = 5 * 1024 * 1024;
 
 // Parsed RLS LB policy configuration.
@@ -115,25 +146,26 @@ class RlsLbConfig : public LoadBalancingPolicy::Config {
   struct RouteLookupConfig {
     KeyBuilderMap key_builder_map;
     std::string lookup_service;
-    grpc_millis lookup_service_timeout = 0;
-    grpc_millis max_age = 0;
-    grpc_millis stale_age = 0;
+    Duration lookup_service_timeout = kDefaultLookupServiceTimeout;
+    Duration max_age = kMaxMaxAge;
+    Duration stale_age = kMaxMaxAge;
     int64_t cache_size_bytes = 0;
     std::string default_target;
+
+    static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+    void JsonPostLoad(const Json& json, const JsonArgs& args,
+                      ValidationErrors* errors);
   };
 
-  RlsLbConfig(RouteLookupConfig route_lookup_config, Json child_policy_config,
-              std::string child_policy_config_target_field_name,
-              RefCountedPtr<LoadBalancingPolicy::Config>
-                  default_child_policy_parsed_config)
-      : route_lookup_config_(std::move(route_lookup_config)),
-        child_policy_config_(std::move(child_policy_config)),
-        child_policy_config_target_field_name_(
-            std::move(child_policy_config_target_field_name)),
-        default_child_policy_parsed_config_(
-            std::move(default_child_policy_parsed_config)) {}
+  RlsLbConfig() = default;
+
+  RlsLbConfig(const RlsLbConfig&) = delete;
+  RlsLbConfig& operator=(const RlsLbConfig&) = delete;
 
-  const char* name() const override { return kRls; }
+  RlsLbConfig(RlsLbConfig&& other) = delete;
+  RlsLbConfig& operator=(RlsLbConfig&& other) = delete;
+
+  absl::string_view name() const override { return kRls; }
 
   const KeyBuilderMap& key_builder_map() const {
     return route_lookup_config_.key_builder_map;
@@ -141,17 +173,20 @@ class RlsLbConfig : public LoadBalancingPolicy::Config {
   const std::string& lookup_service() const {
     return route_lookup_config_.lookup_service;
   }
-  grpc_millis lookup_service_timeout() const {
+  Duration lookup_service_timeout() const {
     return route_lookup_config_.lookup_service_timeout;
   }
-  grpc_millis max_age() const { return route_lookup_config_.max_age; }
-  grpc_millis stale_age() const { return route_lookup_config_.stale_age; }
+  Duration max_age() const { return route_lookup_config_.max_age; }
+  Duration stale_age() const { return route_lookup_config_.stale_age; }
   int64_t cache_size_bytes() const {
     return route_lookup_config_.cache_size_bytes;
   }
   const std::string& default_target() const {
     return route_lookup_config_.default_target;
   }
+  const std::string& rls_channel_service_config() const {
+    return rls_channel_service_config_;
+  }
   const Json& child_policy_config() const { return child_policy_config_; }
   const std::string& child_policy_config_target_field_name() const {
     return child_policy_config_target_field_name_;
@@ -161,8 +196,13 @@ class RlsLbConfig : public LoadBalancingPolicy::Config {
     return default_child_policy_parsed_config_;
   }
 
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+  void JsonPostLoad(const Json& json, const JsonArgs&,
+                    ValidationErrors* errors);
+
  private:
   RouteLookupConfig route_lookup_config_;
+  std::string rls_channel_service_config_;
   Json child_policy_config_;
   std::string child_policy_config_target_field_name_;
   RefCountedPtr<LoadBalancingPolicy::Config>
@@ -174,8 +214,8 @@ class RlsLb : public LoadBalancingPolicy {
  public:
   explicit RlsLb(Args args);
 
-  const char* name() const override { return kRls; }
-  void UpdateLocked(UpdateArgs args) override;
+  absl::string_view name() const override { return kRls; }
+  absl::Status UpdateLocked(UpdateArgs args) override;
   void ExitIdleLocked() override;
   void ResetBackoffLocked() override;
 
@@ -260,8 +300,7 @@ class RlsLb : public LoadBalancingPolicy {
     //
     // Both methods grab the data they need from the parent object.
     void StartUpdate() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&RlsLb::mu_);
-    // Does not take ownership of channel_args.
-    void MaybeFinishUpdate() ABSL_LOCKS_EXCLUDED(&RlsLb::mu_);
+    absl::Status MaybeFinishUpdate() ABSL_LOCKS_EXCLUDED(&RlsLb::mu_);
 
     void ExitIdleLocked() {
       if (child_policy_ != nullptr) child_policy_->ExitIdleLocked();
@@ -292,12 +331,13 @@ class RlsLb : public LoadBalancingPolicy {
       }
 
       RefCountedPtr<SubchannelInterface> CreateSubchannel(
-          ServerAddress address, const grpc_channel_args& args) override;
+          ServerAddress address, const ChannelArgs& args) override;
       void UpdateState(grpc_connectivity_state state,
                        const absl::Status& status,
-                       std::unique_ptr<SubchannelPicker> picker) override;
+                       RefCountedPtr<SubchannelPicker> picker) override;
       void RequestReresolution() override;
       absl::string_view GetAuthority() override;
+      grpc_event_engine::experimental::EventEngine* GetEventEngine() override;
       void AddTraceEvent(TraceSeverity severity,
                          absl::string_view message) override;
 
@@ -315,7 +355,7 @@ class RlsLb : public LoadBalancingPolicy {
 
     grpc_connectivity_state connectivity_state_ ABSL_GUARDED_BY(&RlsLb::mu_) =
         GRPC_CHANNEL_IDLE;
-    std::unique_ptr<LoadBalancingPolicy::SubchannelPicker> picker_
+    RefCountedPtr<LoadBalancingPolicy::SubchannelPicker> picker_
         ABSL_GUARDED_BY(&RlsLb::mu_);
   };
 
@@ -353,15 +393,15 @@ class RlsLb : public LoadBalancingPolicy {
           ABSL_EXCLUSIVE_LOCKS_REQUIRED(&RlsLb::mu_) {
         return status_;
       }
-      grpc_millis backoff_time() const
+      Timestamp backoff_time() const
           ABSL_EXCLUSIVE_LOCKS_REQUIRED(&RlsLb::mu_) {
         return backoff_time_;
       }
-      grpc_millis backoff_expiration_time() const
+      Timestamp backoff_expiration_time() const
           ABSL_EXCLUSIVE_LOCKS_REQUIRED(&RlsLb::mu_) {
         return backoff_expiration_time_;
       }
-      grpc_millis data_expiration_time() const
+      Timestamp data_expiration_time() const
           ABSL_EXCLUSIVE_LOCKS_REQUIRED(&RlsLb::mu_) {
         return data_expiration_time_;
       }
@@ -369,11 +409,10 @@ class RlsLb : public LoadBalancingPolicy {
           ABSL_EXCLUSIVE_LOCKS_REQUIRED(&RlsLb::mu_) {
         return header_data_;
       }
-      grpc_millis stale_time() const
-          ABSL_EXCLUSIVE_LOCKS_REQUIRED(&RlsLb::mu_) {
+      Timestamp stale_time() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(&RlsLb::mu_) {
         return stale_time_;
       }
-      grpc_millis min_expiration_time() const
+      Timestamp min_expiration_time() const
           ABSL_EXCLUSIVE_LOCKS_REQUIRED(&RlsLb::mu_) {
         return min_expiration_time_;
       }
@@ -414,7 +453,7 @@ class RlsLb : public LoadBalancingPolicy {
      private:
       class BackoffTimer : public InternallyRefCounted<BackoffTimer> {
        public:
-        BackoffTimer(RefCountedPtr<Entry> entry, grpc_millis backoff_time);
+        BackoffTimer(RefCountedPtr<Entry> entry, Timestamp backoff_time);
 
         // Note: We are forced to disable lock analysis here because
         // Orphan() is called by OrphanablePtr<>, which cannot have lock
@@ -422,12 +461,11 @@ class RlsLb : public LoadBalancingPolicy {
         void Orphan() override ABSL_NO_THREAD_SAFETY_ANALYSIS;
 
        private:
-        static void OnBackoffTimer(void* args, grpc_error_handle error);
+        void OnBackoffTimerLocked();
 
         RefCountedPtr<Entry> entry_;
-        bool armed_ ABSL_GUARDED_BY(&RlsLb::mu_) = true;
-        grpc_timer backoff_timer_;
-        grpc_closure backoff_timer_callback_;
+        absl::optional<EventEngine::TaskHandle> backoff_timer_task_handle_
+            ABSL_GUARDED_BY(&RlsLb::mu_);
       };
 
       RefCountedPtr<RlsLb> lb_policy_;
@@ -437,22 +475,21 @@ class RlsLb : public LoadBalancingPolicy {
       // Backoff states
       absl::Status status_ ABSL_GUARDED_BY(&RlsLb::mu_);
       std::unique_ptr<BackOff> backoff_state_ ABSL_GUARDED_BY(&RlsLb::mu_);
-      grpc_millis backoff_time_ ABSL_GUARDED_BY(&RlsLb::mu_) =
-          GRPC_MILLIS_INF_PAST;
-      grpc_millis backoff_expiration_time_ ABSL_GUARDED_BY(&RlsLb::mu_) =
-          GRPC_MILLIS_INF_PAST;
+      Timestamp backoff_time_ ABSL_GUARDED_BY(&RlsLb::mu_) =
+          Timestamp::InfPast();
+      Timestamp backoff_expiration_time_ ABSL_GUARDED_BY(&RlsLb::mu_) =
+          Timestamp::InfPast();
       OrphanablePtr<BackoffTimer> backoff_timer_;
 
       // RLS response states
       std::vector<RefCountedPtr<ChildPolicyWrapper>> child_policy_wrappers_
           ABSL_GUARDED_BY(&RlsLb::mu_);
       std::string header_data_ ABSL_GUARDED_BY(&RlsLb::mu_);
-      grpc_millis data_expiration_time_ ABSL_GUARDED_BY(&RlsLb::mu_) =
-          GRPC_MILLIS_INF_PAST;
-      grpc_millis stale_time_ ABSL_GUARDED_BY(&RlsLb::mu_) =
-          GRPC_MILLIS_INF_PAST;
+      Timestamp data_expiration_time_ ABSL_GUARDED_BY(&RlsLb::mu_) =
+          Timestamp::InfPast();
+      Timestamp stale_time_ ABSL_GUARDED_BY(&RlsLb::mu_) = Timestamp::InfPast();
 
-      grpc_millis min_expiration_time_ ABSL_GUARDED_BY(&RlsLb::mu_);
+      Timestamp min_expiration_time_ ABSL_GUARDED_BY(&RlsLb::mu_);
       Cache::Iterator lru_iterator_ ABSL_GUARDED_BY(&RlsLb::mu_);
     };
 
@@ -484,7 +521,10 @@ class RlsLb : public LoadBalancingPolicy {
     void Shutdown() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&RlsLb::mu_);
 
    private:
-    static void OnCleanupTimer(void* arg, grpc_error_handle error);
+    // Shared logic for starting the cleanup timer
+    void StartCleanupTimer() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&RlsLb::mu_);
+
+    void OnCleanupTimer();
 
     // Returns the entry size for a given key.
     static size_t EntrySizeForKey(const RequestKey& key);
@@ -502,16 +542,14 @@ class RlsLb : public LoadBalancingPolicy {
     std::list<RequestKey> lru_list_ ABSL_GUARDED_BY(&RlsLb::mu_);
     std::unordered_map<RequestKey, OrphanablePtr<Entry>, absl::Hash<RequestKey>>
         map_ ABSL_GUARDED_BY(&RlsLb::mu_);
-    grpc_timer cleanup_timer_;
-    grpc_closure timer_callback_;
+    absl::optional<EventEngine::TaskHandle> cleanup_timer_handle_;
   };
 
   // Channel for communicating with the RLS server.
   // Contains throttling logic for RLS requests.
   class RlsChannel : public InternallyRefCounted<RlsChannel> {
    public:
-    RlsChannel(RefCountedPtr<RlsLb> lb_policy, const std::string& target,
-               const grpc_channel_args* parent_channel_args);
+    explicit RlsChannel(RefCountedPtr<RlsLb> lb_policy);
 
     // Shuts down the channel.
     void Orphan() override;
@@ -557,8 +595,13 @@ class RlsLb : public LoadBalancingPolicy {
     // Throttle state for RLS requests.
     class Throttle {
      public:
-      explicit Throttle(int window_size_seconds = 0,
-                        double ratio_for_successes = 0, int paddings = 0);
+      explicit Throttle(
+          Duration window_size = kDefaultThrottleWindowSize,
+          float ratio_for_successes = kDefaultThrottleRatioForSuccesses,
+          int padding = kDefaultThrottlePadding)
+          : window_size_(window_size),
+            ratio_for_successes_(ratio_for_successes),
+            padding_(padding) {}
 
       bool ShouldThrottle() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&RlsLb::mu_);
 
@@ -566,15 +609,16 @@ class RlsLb : public LoadBalancingPolicy {
           ABSL_EXCLUSIVE_LOCKS_REQUIRED(&RlsLb::mu_);
 
      private:
-      grpc_millis window_size_;
+      Duration window_size_;
       double ratio_for_successes_;
-      int paddings_;
+      int padding_;
+      std::mt19937 rng_{std::random_device()()};
 
       // Logged timestamp of requests.
-      std::deque<grpc_millis> requests_ ABSL_GUARDED_BY(&RlsLb::mu_);
+      std::deque<Timestamp> requests_ ABSL_GUARDED_BY(&RlsLb::mu_);
 
-      // Logged timestamp of responses that were successful.
-      std::deque<grpc_millis> successes_ ABSL_GUARDED_BY(&RlsLb::mu_);
+      // Logged timestamps of failures.
+      std::deque<Timestamp> failures_ ABSL_GUARDED_BY(&RlsLb::mu_);
     };
 
     RefCountedPtr<RlsLb> lb_policy_;
@@ -627,7 +671,7 @@ class RlsLb : public LoadBalancingPolicy {
     std::string stale_header_data_;
 
     // RLS call state.
-    grpc_millis deadline_;
+    Timestamp deadline_;
     grpc_closure call_start_cb_;
     grpc_closure call_complete_cb_;
     grpc_call* call_ = nullptr;
@@ -656,6 +700,7 @@ class RlsLb : public LoadBalancingPolicy {
   // Mutex to guard LB policy state that is accessed by the picker.
   Mutex mu_;
   bool is_shutdown_ ABSL_GUARDED_BY(mu_) = false;
+  bool update_in_progress_ = false;
   Cache cache_ ABSL_GUARDED_BY(mu_);
   // Maps an RLS request key to an RlsRequest object that represents a pending
   // RLS request.
@@ -669,8 +714,8 @@ class RlsLb : public LoadBalancingPolicy {
   OrphanablePtr<RlsChannel> rls_channel_ ABSL_GUARDED_BY(mu_);
 
   // Accessed only from within WorkSerializer.
-  ServerAddressList addresses_;
-  const grpc_channel_args* channel_args_ = nullptr;
+  absl::StatusOr<ServerAddressList> addresses_;
+  ChannelArgs channel_args_;
   RefCountedPtr<RlsLbConfig> config_;
   RefCountedPtr<ChildPolicyWrapper> default_child_policy_;
   std::map<std::string /*target*/, ChildPolicyWrapper*> child_policy_map_;
@@ -687,7 +732,7 @@ RlsLb::ChildPolicyWrapper::ChildPolicyWrapper(RefCountedPtr<RlsLb> lb_policy,
                                                      : nullptr),
       lb_policy_(lb_policy),
       target_(std::move(target)),
-      picker_(absl::make_unique<QueuePicker>(std::move(lb_policy))) {
+      picker_(MakeRefCounted<QueuePicker>(std::move(lb_policy))) {
   lb_policy_->child_policy_map_.emplace(target_, this);
 }
 
@@ -706,28 +751,32 @@ void RlsLb::ChildPolicyWrapper::Orphan() {
   picker_.reset();
 }
 
-grpc_error_handle InsertOrUpdateChildPolicyField(const std::string& field,
-                                                 const std::string& value,
-                                                 Json* config) {
+bool InsertOrUpdateChildPolicyField(const std::string& field,
+                                    const std::string& value, Json* config,
+                                    ValidationErrors* errors) {
   if (config->type() != Json::Type::ARRAY) {
-    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "child policy configuration is not an array");
+    errors->AddError("is not an array");
+    return false;
   }
-  std::vector<grpc_error_handle> error_list;
-  for (Json& child_json : *config->mutable_array()) {
+  bool success = true;
+  for (size_t i = 0; i < config->array_value().size(); ++i) {
+    Json& child_json = (*config->mutable_array())[i];
+    ValidationErrors::ScopedField json_field(errors, absl::StrCat("[", i, "]"));
     if (child_json.type() != Json::Type::OBJECT) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "child policy item is not an object"));
+      errors->AddError("is not an object");
+      success = false;
     } else {
       Json::Object& child = *child_json.mutable_object();
       if (child.size() != 1) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "child policy item contains more than one field"));
+        errors->AddError("child policy object contains more than one field");
+        success = false;
       } else {
+        ValidationErrors::ScopedField json_field(
+            errors, absl::StrCat("[\"", child.begin()->first, "\"]"));
         Json& child_config_json = child.begin()->second;
         if (child_config_json.type() != Json::Type::OBJECT) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-              "child policy item config is not an object"));
+          errors->AddError("child policy config is not an object");
+          success = false;
         } else {
           Json::Object& child_config = *child_config_json.mutable_object();
           child_config[field] = Json(value);
@@ -735,18 +784,15 @@ grpc_error_handle InsertOrUpdateChildPolicyField(const std::string& field,
       }
     }
   }
-  return GRPC_ERROR_CREATE_FROM_VECTOR_AND_CPP_STRING(
-      absl::StrCat("errors when inserting field \"", field,
-                   "\" for child policy"),
-      &error_list);
+  return success;
 }
 
 void RlsLb::ChildPolicyWrapper::StartUpdate() {
   Json child_policy_config = lb_policy_->config_->child_policy_config();
-  grpc_error_handle error = InsertOrUpdateChildPolicyField(
+  ValidationErrors errors;
+  GPR_ASSERT(InsertOrUpdateChildPolicyField(
       lb_policy_->config_->child_policy_config_target_field_name(), target_,
-      &child_policy_config);
-  GPR_ASSERT(error == GRPC_ERROR_NONE);
+      &child_policy_config, &errors));
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
     gpr_log(
         GPR_INFO,
@@ -754,35 +800,36 @@ void RlsLb::ChildPolicyWrapper::StartUpdate() {
         lb_policy_.get(), this, target_.c_str(),
         child_policy_config.Dump().c_str());
   }
-  pending_config_ = LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
-      child_policy_config, &error);
+  auto config =
+      CoreConfiguration::Get().lb_policy_registry().ParseLoadBalancingConfig(
+          child_policy_config);
   // Returned RLS target fails the validation.
-  if (error != GRPC_ERROR_NONE) {
+  if (!config.ok()) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
       gpr_log(GPR_INFO,
               "[rlslb %p] ChildPolicyWrapper=%p [%s]: config failed to parse: "
-              "%s; config: %s",
+              "%s",
               lb_policy_.get(), this, target_.c_str(),
-              grpc_error_std_string(error).c_str(),
-              child_policy_config.Dump().c_str());
+              config.status().ToString().c_str());
     }
     pending_config_.reset();
-    picker_ = absl::make_unique<TransientFailurePicker>(
-        grpc_error_to_absl_status(error));
-    GRPC_ERROR_UNREF(error);
+    picker_ = MakeRefCounted<TransientFailurePicker>(
+        absl::UnavailableError(config.status().message()));
     child_policy_.reset();
+  } else {
+    pending_config_ = std::move(*config);
   }
 }
 
-void RlsLb::ChildPolicyWrapper::MaybeFinishUpdate() {
+absl::Status RlsLb::ChildPolicyWrapper::MaybeFinishUpdate() {
   // If pending_config_ is not set, that means StartUpdate() failed, so
   // there's nothing to do here.
-  if (pending_config_ == nullptr) return;
+  if (pending_config_ == nullptr) return absl::OkStatus();
   // If child policy doesn't yet exist, create it.
   if (child_policy_ == nullptr) {
     Args create_args;
     create_args.work_serializer = lb_policy_->work_serializer();
-    create_args.channel_control_helper = absl::make_unique<ChildPolicyHelper>(
+    create_args.channel_control_helper = std::make_unique<ChildPolicyHelper>(
         WeakRef(DEBUG_LOCATION, "ChildPolicyHelper"));
     create_args.args = lb_policy_->channel_args_;
     child_policy_ = MakeOrphanable<ChildPolicyHandler>(std::move(create_args),
@@ -806,8 +853,8 @@ void RlsLb::ChildPolicyWrapper::MaybeFinishUpdate() {
   UpdateArgs update_args;
   update_args.config = std::move(pending_config_);
   update_args.addresses = lb_policy_->addresses_;
-  update_args.args = grpc_channel_args_copy(lb_policy_->channel_args_);
-  child_policy_->UpdateLocked(std::move(update_args));
+  update_args.args = lb_policy_->channel_args_;
+  return child_policy_->UpdateLocked(std::move(update_args));
 }
 
 //
@@ -816,7 +863,7 @@ void RlsLb::ChildPolicyWrapper::MaybeFinishUpdate() {
 
 RefCountedPtr<SubchannelInterface>
 RlsLb::ChildPolicyWrapper::ChildPolicyHelper::CreateSubchannel(
-    ServerAddress address, const grpc_channel_args& args) {
+    ServerAddress address, const ChannelArgs& args) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
     gpr_log(GPR_INFO,
             "[rlslb %p] ChildPolicyWrapper=%p [%s] ChildPolicyHelper=%p: "
@@ -831,7 +878,7 @@ RlsLb::ChildPolicyWrapper::ChildPolicyHelper::CreateSubchannel(
 
 void RlsLb::ChildPolicyWrapper::ChildPolicyHelper::UpdateState(
     grpc_connectivity_state state, const absl::Status& status,
-    std::unique_ptr<SubchannelPicker> picker) {
+    RefCountedPtr<SubchannelPicker> picker) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
     gpr_log(GPR_INFO,
             "[rlslb %p] ChildPolicyWrapper=%p [%s] ChildPolicyHelper=%p: "
@@ -872,6 +919,11 @@ absl::string_view RlsLb::ChildPolicyWrapper::ChildPolicyHelper::GetAuthority() {
   return wrapper_->lb_policy_->channel_control_helper()->GetAuthority();
 }
 
+grpc_event_engine::experimental::EventEngine*
+RlsLb::ChildPolicyWrapper::ChildPolicyHelper::GetEventEngine() {
+  return wrapper_->lb_policy_->channel_control_helper()->GetEventEngine();
+}
+
 void RlsLb::ChildPolicyWrapper::ChildPolicyHelper::AddTraceEvent(
     TraceSeverity severity, absl::string_view message) {
   if (wrapper_->is_shutdown_) return;
@@ -977,7 +1029,7 @@ LoadBalancingPolicy::PickResult RlsLb::Picker::Pick(PickArgs args) {
     gpr_log(GPR_INFO, "[rlslb %p] picker=%p: request keys: %s",
             lb_policy_.get(), this, key.ToString().c_str());
   }
-  grpc_millis now = ExecCtx::Get()->Now();
+  Timestamp now = Timestamp::Now();
   MutexLock lock(&lb_policy_->mu_);
   if (lb_policy_->is_shutdown_) {
     return PickResult::Fail(
@@ -1047,7 +1099,8 @@ LoadBalancingPolicy::PickResult RlsLb::Picker::Pick(PickArgs args) {
                 "[rlslb %p] picker=%p: RLS call in backoff; failing pick",
                 lb_policy_.get(), this);
       }
-      return PickResult::Fail(entry->status());
+      return PickResult::Fail(absl::UnavailableError(
+          absl::StrCat("RLS request failed: ", entry->status().ToString())));
     }
   }
   // RLS call pending.  Queue the pick.
@@ -1063,48 +1116,52 @@ LoadBalancingPolicy::PickResult RlsLb::Picker::Pick(PickArgs args) {
 //
 
 RlsLb::Cache::Entry::BackoffTimer::BackoffTimer(RefCountedPtr<Entry> entry,
-                                                grpc_millis backoff_time)
+                                                Timestamp backoff_time)
     : entry_(std::move(entry)) {
-  GRPC_CLOSURE_INIT(&backoff_timer_callback_, OnBackoffTimer, this, nullptr);
-  Ref(DEBUG_LOCATION, "BackoffTimer").release();
-  grpc_timer_init(&backoff_timer_, backoff_time, &backoff_timer_callback_);
+  backoff_timer_task_handle_ =
+      entry_->lb_policy_->channel_control_helper()->GetEventEngine()->RunAfter(
+          backoff_time - Timestamp::Now(),
+          [self = Ref(DEBUG_LOCATION, "BackoffTimer")]() mutable {
+            ApplicationCallbackExecCtx callback_exec_ctx;
+            ExecCtx exec_ctx;
+            auto self_ptr = self.get();
+            self_ptr->entry_->lb_policy_->work_serializer()->Run(
+                [self = std::move(self)]() { self->OnBackoffTimerLocked(); },
+                DEBUG_LOCATION);
+          });
 }
 
 void RlsLb::Cache::Entry::BackoffTimer::Orphan() {
-  if (armed_) {
-    armed_ = false;
-    grpc_timer_cancel(&backoff_timer_);
+  if (backoff_timer_task_handle_.has_value() &&
+      entry_->lb_policy_->channel_control_helper()->GetEventEngine()->Cancel(
+          *backoff_timer_task_handle_)) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
+      gpr_log(GPR_INFO, "[rlslb %p] cache entry=%p %s, backoff timer canceled",
+              entry_->lb_policy_.get(), entry_.get(),
+              entry_->is_shutdown_ ? "(shut down)"
+                                   : entry_->lru_iterator_->ToString().c_str());
+    }
   }
+  backoff_timer_task_handle_.reset();
   Unref(DEBUG_LOCATION, "Orphan");
 }
 
-void RlsLb::Cache::Entry::BackoffTimer::OnBackoffTimer(
-    void* arg, grpc_error_handle /*error*/) {
-  auto* self = static_cast<BackoffTimer*>(arg);
-  self->entry_->lb_policy_->work_serializer()->Run(
-      [self]() {
-        RefCountedPtr<BackoffTimer> backoff_timer(self);
-        {
-          MutexLock lock(&self->entry_->lb_policy_->mu_);
-          if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
-            gpr_log(GPR_INFO,
-                    "[rlslb %p] cache entry=%p %s, armed_=%d: "
-                    "backoff timer fired",
-                    self->entry_->lb_policy_.get(), self->entry_.get(),
-                    self->entry_->is_shutdown_
-                        ? "(shut down)"
-                        : self->entry_->lru_iterator_->ToString().c_str(),
-                    self->armed_);
-          }
-          bool cancelled = !self->armed_;
-          self->armed_ = false;
-          if (cancelled) return;
-        }
-        // The pick was in backoff state and there could be a pick queued if
-        // wait_for_ready is true. We'll update the picker for that case.
-        self->entry_->lb_policy_->UpdatePickerLocked();
-      },
-      DEBUG_LOCATION);
+void RlsLb::Cache::Entry::BackoffTimer::OnBackoffTimerLocked() {
+  {
+    MutexLock lock(&entry_->lb_policy_->mu_);
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
+      gpr_log(GPR_INFO, "[rlslb %p] cache entry=%p %s, backoff timer fired",
+              entry_->lb_policy_.get(), entry_.get(),
+              entry_->is_shutdown_ ? "(shut down)"
+                                   : entry_->lru_iterator_->ToString().c_str());
+    }
+    // Skip the update if Orphaned
+    if (!backoff_timer_task_handle_.has_value()) return;
+    backoff_timer_task_handle_.reset();
+  }
+  // The pick was in backoff state and there could be a pick queued if
+  // wait_for_ready is true. We'll update the picker for that case.
+  entry_->lb_policy_->UpdatePickerLocked();
 }
 
 //
@@ -1112,7 +1169,7 @@ void RlsLb::Cache::Entry::BackoffTimer::OnBackoffTimer(
 //
 
 std::unique_ptr<BackOff> MakeCacheEntryBackoff() {
-  return absl::make_unique<BackOff>(
+  return std::make_unique<BackOff>(
       BackOff::Options()
           .set_initial_backoff(kCacheBackoffInitial)
           .set_multiplier(kCacheBackoffMultiplier)
@@ -1126,7 +1183,7 @@ RlsLb::Cache::Entry::Entry(RefCountedPtr<RlsLb> lb_policy,
           GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace) ? "CacheEntry" : nullptr),
       lb_policy_(std::move(lb_policy)),
       backoff_state_(MakeCacheEntryBackoff()),
-      min_expiration_time_(ExecCtx::Get()->Now() + kMinExpirationTime),
+      min_expiration_time_(Timestamp::Now() + kMinExpirationTime),
       lru_iterator_(lb_policy_->cache_.lru_list_.insert(
           lb_policy_->cache_.lru_list_.end(), key)) {}
 
@@ -1154,60 +1211,62 @@ size_t RlsLb::Cache::Entry::Size() const {
 }
 
 LoadBalancingPolicy::PickResult RlsLb::Cache::Entry::Pick(PickArgs args) {
-  for (const auto& child_policy_wrapper : child_policy_wrappers_) {
+  size_t i = 0;
+  ChildPolicyWrapper* child_policy_wrapper = nullptr;
+  // Skip targets before the last one that are in state TRANSIENT_FAILURE.
+  for (; i < child_policy_wrappers_.size(); ++i) {
+    child_policy_wrapper = child_policy_wrappers_[i].get();
     if (child_policy_wrapper->connectivity_state() ==
-        GRPC_CHANNEL_TRANSIENT_FAILURE) {
+            GRPC_CHANNEL_TRANSIENT_FAILURE &&
+        i < child_policy_wrappers_.size() - 1) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
         gpr_log(GPR_INFO,
-                "[rlslb %p] cache entry=%p %s: target %s in state "
-                "TRANSIENT_FAILURE; skipping",
+                "[rlslb %p] cache entry=%p %s: target %s (%" PRIuPTR
+                " of %" PRIuPTR ") in state TRANSIENT_FAILURE; skipping",
                 lb_policy_.get(), this, lru_iterator_->ToString().c_str(),
-                child_policy_wrapper->target().c_str());
+                child_policy_wrapper->target().c_str(), i,
+                child_policy_wrappers_.size());
       }
       continue;
     }
-    // Child policy not in TRANSIENT_FAILURE, so delegate.
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
-      gpr_log(
-          GPR_INFO,
-          "[rlslb %p] cache entry=%p %s: target %s in state %s; "
-          "delegating",
-          lb_policy_.get(), this, lru_iterator_->ToString().c_str(),
-          child_policy_wrapper->target().c_str(),
-          ConnectivityStateName(child_policy_wrapper->connectivity_state()));
-    }
-    // Add header data.
-    if (!header_data_.empty()) {
-      char* copied_header_data =
-          static_cast<char*>(args.call_state->Alloc(header_data_.length() + 1));
-      strcpy(copied_header_data, header_data_.c_str());
-      args.initial_metadata->Add(kRlsHeaderKey, copied_header_data);
-    }
-    return child_policy_wrapper->Pick(args);
+    break;
   }
-  // No child policy found.
+  // Child policy not in TRANSIENT_FAILURE or is the last target in
+  // the list, so delegate.
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
     gpr_log(GPR_INFO,
-            "[rlslb %p] cache entry=%p %s: no healthy target found; "
-            "failing pick",
-            lb_policy_.get(), this, lru_iterator_->ToString().c_str());
-  }
-  return PickResult::Fail(
-      absl::UnavailableError("all RLS targets unreachable"));
+            "[rlslb %p] cache entry=%p %s: target %s (%" PRIuPTR " of %" PRIuPTR
+            ") in state %s; delegating",
+            lb_policy_.get(), this, lru_iterator_->ToString().c_str(),
+            child_policy_wrapper->target().c_str(), i,
+            child_policy_wrappers_.size(),
+            ConnectivityStateName(child_policy_wrapper->connectivity_state()));
+  }
+  // Add header data.
+  // Note that even if the target we're using is in TRANSIENT_FAILURE,
+  // the pick might still succeed (e.g., if the child is ring_hash), so
+  // we need to pass the right header info down in all cases.
+  if (!header_data_.empty()) {
+    char* copied_header_data =
+        static_cast<char*>(args.call_state->Alloc(header_data_.length() + 1));
+    strcpy(copied_header_data, header_data_.c_str());
+    args.initial_metadata->Add(kRlsHeaderKey, copied_header_data);
+  }
+  return child_policy_wrapper->Pick(args);
 }
 
 void RlsLb::Cache::Entry::ResetBackoff() {
-  backoff_time_ = GRPC_MILLIS_INF_PAST;
+  backoff_time_ = Timestamp::InfPast();
   backoff_timer_.reset();
 }
 
 bool RlsLb::Cache::Entry::ShouldRemove() const {
-  grpc_millis now = ExecCtx::Get()->Now();
+  Timestamp now = Timestamp::Now();
   return data_expiration_time_ < now && backoff_expiration_time_ < now;
 }
 
 bool RlsLb::Cache::Entry::CanEvict() const {
-  grpc_millis now = ExecCtx::Get()->Now();
+  Timestamp now = Timestamp::Now();
   return min_expiration_time_ < now;
 }
 
@@ -1233,7 +1292,7 @@ RlsLb::Cache::Entry::OnRlsResponseLocked(
       backoff_state_ = MakeCacheEntryBackoff();
     }
     backoff_time_ = backoff_state_->NextAttemptTime();
-    grpc_millis now = ExecCtx::Get()->Now();
+    Timestamp now = Timestamp::Now();
     backoff_expiration_time_ = now + (backoff_time_ - now) * 2;
     backoff_timer_ = MakeOrphanable<BackoffTimer>(
         Ref(DEBUG_LOCATION, "BackoffTimer"), backoff_time_);
@@ -1242,13 +1301,13 @@ RlsLb::Cache::Entry::OnRlsResponseLocked(
   }
   // Request succeeded, so store the result.
   header_data_ = std::move(response.header_data);
-  grpc_millis now = ExecCtx::Get()->Now();
+  Timestamp now = Timestamp::Now();
   data_expiration_time_ = now + lb_policy_->config_->max_age();
   stale_time_ = now + lb_policy_->config_->stale_age();
   status_ = absl::OkStatus();
   backoff_state_.reset();
-  backoff_time_ = GRPC_MILLIS_INF_PAST;
-  backoff_expiration_time_ = GRPC_MILLIS_INF_PAST;
+  backoff_time_ = Timestamp::InfPast();
+  backoff_expiration_time_ = Timestamp::InfPast();
   // Check if we need to update this list of targets.
   bool targets_changed = [&]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&RlsLb::mu_) {
     if (child_policy_wrappers_.size() != response.targets.size()) return true;
@@ -1308,11 +1367,7 @@ RlsLb::Cache::Entry::OnRlsResponseLocked(
 //
 
 RlsLb::Cache::Cache(RlsLb* lb_policy) : lb_policy_(lb_policy) {
-  grpc_millis now = ExecCtx::Get()->Now();
-  lb_policy_->Ref(DEBUG_LOCATION, "CacheCleanupTimer").release();
-  GRPC_CLOSURE_INIT(&timer_callback_, OnCleanupTimer, this, nullptr);
-  grpc_timer_init(&cleanup_timer_, now + kCacheCleanupTimerInterval,
-                  &timer_callback_);
+  StartCleanupTimer();
 }
 
 RlsLb::Cache::Entry* RlsLb::Cache::Find(const RequestKey& key) {
@@ -1366,38 +1421,49 @@ void RlsLb::Cache::ResetAllBackoff() {
 void RlsLb::Cache::Shutdown() {
   map_.clear();
   lru_list_.clear();
-  grpc_timer_cancel(&cleanup_timer_);
+  if (cleanup_timer_handle_.has_value() &&
+      lb_policy_->channel_control_helper()->GetEventEngine()->Cancel(
+          *cleanup_timer_handle_)) {
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
+      gpr_log(GPR_INFO, "[rlslb %p] cache cleanup timer canceled", lb_policy_);
+    }
+  }
+  cleanup_timer_handle_.reset();
 }
 
-void RlsLb::Cache::OnCleanupTimer(void* arg, grpc_error_handle error) {
-  Cache* cache = static_cast<Cache*>(arg);
-  GRPC_ERROR_REF(error);
-  cache->lb_policy_->work_serializer()->Run(
-      [cache, error]() {
-        RefCountedPtr<RlsLb> lb_policy(cache->lb_policy_);
-        if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
-          gpr_log(GPR_INFO, "[rlslb %p] cache cleanup timer fired (%s)",
-                  cache->lb_policy_, grpc_error_std_string(error).c_str());
-        }
-        if (error == GRPC_ERROR_CANCELLED) return;
-        MutexLock lock(&lb_policy->mu_);
-        if (lb_policy->is_shutdown_) return;
-        for (auto it = cache->map_.begin(); it != cache->map_.end();) {
-          if (GPR_UNLIKELY(it->second->ShouldRemove() &&
-                           it->second->CanEvict())) {
-            cache->size_ -= it->second->Size();
-            it = cache->map_.erase(it);
-          } else {
-            ++it;
-          }
-        }
-        grpc_millis now = ExecCtx::Get()->Now();
-        lb_policy.release();
-        grpc_timer_init(&cache->cleanup_timer_,
-                        now + kCacheCleanupTimerInterval,
-                        &cache->timer_callback_);
-      },
-      DEBUG_LOCATION);
+void RlsLb::Cache::StartCleanupTimer() {
+  cleanup_timer_handle_ =
+      lb_policy_->channel_control_helper()->GetEventEngine()->RunAfter(
+          kCacheCleanupTimerInterval,
+          [this, lb_policy = lb_policy_->Ref(DEBUG_LOCATION,
+                                             "CacheCleanupTimer")]() mutable {
+            ApplicationCallbackExecCtx callback_exec_ctx;
+            ExecCtx exec_ctx;
+            lb_policy_->work_serializer()->Run(
+                [this, lb_policy = std::move(lb_policy)]() {
+                  // The lb_policy ref is held until the callback completes
+                  OnCleanupTimer();
+                },
+                DEBUG_LOCATION);
+          });
+}
+
+void RlsLb::Cache::OnCleanupTimer() {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
+    gpr_log(GPR_INFO, "[rlslb %p] cache cleanup timer fired", lb_policy_);
+  }
+  MutexLock lock(&lb_policy_->mu_);
+  if (!cleanup_timer_handle_.has_value()) return;
+  if (lb_policy_->is_shutdown_) return;
+  for (auto it = map_.begin(); it != map_.end();) {
+    if (GPR_UNLIKELY(it->second->ShouldRemove() && it->second->CanEvict())) {
+      size_ -= it->second->Size();
+      it = map_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+  StartCleanupTimer();
 }
 
 size_t RlsLb::Cache::EntrySizeForKey(const RequestKey& key) {
@@ -1459,98 +1525,95 @@ void RlsLb::RlsChannel::StateWatcher::OnConnectivityStateChange(
 // RlsLb::RlsChannel::Throttle
 //
 
-RlsLb::RlsChannel::Throttle::Throttle(int window_size_seconds,
-                                      double ratio_for_successes,
-                                      int paddings) {
-  GPR_DEBUG_ASSERT(window_size_seconds >= 0);
-  GPR_DEBUG_ASSERT(ratio_for_successes >= 0);
-  GPR_DEBUG_ASSERT(paddings >= 0);
-  window_size_ = window_size_seconds == 0 ? window_size_seconds * GPR_MS_PER_SEC
-                                          : kDefaultThrottleWindowSize;
-  ratio_for_successes_ = ratio_for_successes == 0
-                             ? kDefaultThrottleRatioForSuccesses
-                             : ratio_for_successes;
-  paddings_ = paddings == 0 ? kDefaultThrottlePaddings : paddings;
-}
-
 bool RlsLb::RlsChannel::Throttle::ShouldThrottle() {
-  grpc_millis now = ExecCtx::Get()->Now();
+  Timestamp now = Timestamp::Now();
   while (!requests_.empty() && now - requests_.front() > window_size_) {
     requests_.pop_front();
   }
-  while (!successes_.empty() && now - successes_.front() > window_size_) {
-    successes_.pop_front();
-  }
-  int successes = successes_.size();
-  int requests = requests_.size();
-  bool result = ((rand() % (requests + paddings_)) <
-                 static_cast<double>(requests) -
-                     static_cast<double>(successes) * ratio_for_successes_);
-  requests_.push_back(now);
-  return result;
+  while (!failures_.empty() && now - failures_.front() > window_size_) {
+    failures_.pop_front();
+  }
+  // Compute probability of throttling.
+  float num_requests = requests_.size();
+  float num_successes = num_requests - failures_.size();
+  // Note: it's possible that this ratio will be negative, in which case
+  // no throttling will be done.
+  float throttle_probability =
+      (num_requests - (num_successes * ratio_for_successes_)) /
+      (num_requests + padding_);
+  // Generate a random number for the request.
+  std::uniform_real_distribution<float> dist(0, 1.0);
+  // Check if we should throttle the request.
+  bool throttle = dist(rng_) < throttle_probability;
+  // If we're throttling, record the request and the failure.
+  if (throttle) {
+    requests_.push_back(now);
+    failures_.push_back(now);
+  }
+  return throttle;
 }
 
 void RlsLb::RlsChannel::Throttle::RegisterResponse(bool success) {
-  if (success) {
-    successes_.push_back(ExecCtx::Get()->Now());
-  }
+  Timestamp now = Timestamp::Now();
+  requests_.push_back(now);
+  if (!success) failures_.push_back(now);
 }
 
 //
 // RlsLb::RlsChannel
 //
 
-RlsLb::RlsChannel::RlsChannel(RefCountedPtr<RlsLb> lb_policy,
-                              const std::string& target,
-                              const grpc_channel_args* parent_channel_args)
+RlsLb::RlsChannel::RlsChannel(RefCountedPtr<RlsLb> lb_policy)
     : InternallyRefCounted<RlsChannel>(
           GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace) ? "RlsChannel" : nullptr),
       lb_policy_(std::move(lb_policy)) {
   // Get channel creds from parent channel.
   // TODO(roth): Once we eliminate insecure builds, get this via a
   // method on the helper instead of digging through channel args.
-  grpc_channel_credentials* creds =
-      grpc_channel_credentials_find_in_args(parent_channel_args);
+  auto* creds = lb_policy_->channel_args_.GetObject<grpc_channel_credentials>();
   // Use the parent channel's authority.
   std::string authority(lb_policy_->channel_control_helper()->GetAuthority());
-  absl::InlinedVector<grpc_arg, 3> args = {
-      grpc_channel_arg_string_create(
-          const_cast<char*>(GRPC_ARG_DEFAULT_AUTHORITY),
-          const_cast<char*>(authority.c_str())),
-      grpc_channel_arg_integer_create(
-          const_cast<char*>(GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL), 1),
-  };
+  ChannelArgs args = ChannelArgs()
+                         .Set(GRPC_ARG_DEFAULT_AUTHORITY, authority)
+                         .Set(GRPC_ARG_CHANNELZ_IS_INTERNAL_CHANNEL, 1);
   // Propagate fake security connector expected targets, if any.
   // (This is ugly, but it seems better than propagating all channel args
   // from the parent channel by default and then having a giant
   // exclude list of args to strip out, like we do in grpclb.)
-  const char* fake_security_expected_targets = grpc_channel_args_find_string(
-      parent_channel_args, GRPC_ARG_FAKE_SECURITY_EXPECTED_TARGETS);
-  if (fake_security_expected_targets != nullptr) {
-    args.push_back(grpc_channel_arg_string_create(
-        const_cast<char*>(GRPC_ARG_FAKE_SECURITY_EXPECTED_TARGETS),
-        const_cast<char*>(fake_security_expected_targets)));
-  }
-  grpc_channel_args rls_channel_args = {args.size(), args.data()};
-  channel_ = grpc_secure_channel_create(creds, target.c_str(),
-                                        &rls_channel_args, nullptr);
+  absl::optional<absl::string_view> fake_security_expected_targets =
+      lb_policy_->channel_args_.GetString(
+          GRPC_ARG_FAKE_SECURITY_EXPECTED_TARGETS);
+  if (fake_security_expected_targets.has_value()) {
+    args = args.Set(GRPC_ARG_FAKE_SECURITY_EXPECTED_TARGETS,
+                    *fake_security_expected_targets);
+  }
+  // Add service config args if needed.
+  const std::string& service_config =
+      lb_policy_->config_->rls_channel_service_config();
+  if (!service_config.empty()) {
+    args = args.Set(GRPC_ARG_SERVICE_CONFIG, service_config)
+               .Set(GRPC_ARG_SERVICE_CONFIG_DISABLE_RESOLUTION, 1);
+  }
+  channel_ = grpc_channel_create(lb_policy_->config_->lookup_service().c_str(),
+                                 creds, args.ToC().get());
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
     gpr_log(GPR_INFO, "[rlslb %p] RlsChannel=%p: created channel %p for %s",
-            lb_policy_.get(), this, channel_, target.c_str());
+            lb_policy_.get(), this, channel_,
+            lb_policy_->config_->lookup_service().c_str());
   }
   if (channel_ != nullptr) {
     // Set up channelz linkage.
     channelz::ChannelNode* child_channelz_node =
         grpc_channel_get_channelz_node(channel_);
     channelz::ChannelNode* parent_channelz_node =
-        grpc_channel_args_find_pointer<channelz::ChannelNode>(
-            parent_channel_args, GRPC_ARG_CHANNELZ_CHANNEL_NODE);
+        lb_policy_->channel_args_.GetObject<channelz::ChannelNode>();
     if (child_channelz_node != nullptr && parent_channelz_node != nullptr) {
       parent_channelz_node->AddChildChannel(child_channelz_node->uuid());
       parent_channelz_node_ = parent_channelz_node->Ref();
     }
     // Start connectivity watch.
-    ClientChannel* client_channel = ClientChannel::GetFromChannel(channel_);
+    ClientChannel* client_channel =
+        ClientChannel::GetFromChannel(Channel::FromC(channel_));
     GPR_ASSERT(client_channel != nullptr);
     watcher_ = new StateWatcher(Ref(DEBUG_LOCATION, "StateWatcher"));
     client_channel->AddConnectivityWatcher(
@@ -1575,7 +1638,8 @@ void RlsLb::RlsChannel::Orphan() {
     }
     // Stop connectivity watch.
     if (watcher_ != nullptr) {
-      ClientChannel* client_channel = ClientChannel::GetFromChannel(channel_);
+      ClientChannel* client_channel =
+          ClientChannel::GetFromChannel(Channel::FromC(channel_));
       GPR_ASSERT(client_channel != nullptr);
       client_channel->RemoveConnectivityWatcher(watcher_);
       watcher_ = nullptr;
@@ -1639,7 +1703,7 @@ RlsLb::RlsRequest::RlsRequest(RefCountedPtr<RlsLb> lb_policy, RequestKey key,
       DEBUG_LOCATION,
       GRPC_CLOSURE_INIT(&call_start_cb_, StartCall,
                         Ref(DEBUG_LOCATION, "StartCall").release(), nullptr),
-      GRPC_ERROR_NONE);
+      absl::OkStatus());
 }
 
 RlsLb::RlsRequest::~RlsRequest() { GPR_ASSERT(call_ == nullptr); }
@@ -1670,7 +1734,7 @@ void RlsLb::RlsRequest::StartCallLocked() {
     MutexLock lock(&lb_policy_->mu_);
     if (lb_policy_->is_shutdown_) return;
   }
-  grpc_millis now = ExecCtx::Get()->Now();
+  Timestamp now = Timestamp::Now();
   deadline_ = now + lb_policy_->config_->lookup_service_timeout();
   grpc_metadata_array_init(&recv_initial_metadata_);
   grpc_metadata_array_init(&recv_trailing_metadata_);
@@ -1710,7 +1774,6 @@ void RlsLb::RlsRequest::StartCallLocked() {
 
 void RlsLb::RlsRequest::OnRlsCallComplete(void* arg, grpc_error_handle error) {
   auto* request = static_cast<RlsRequest*>(arg);
-  GRPC_ERROR_REF(error);
   request->lb_policy_->work_serializer()->Run(
       [request, error]() {
         request->OnRlsCallCompleteLocked(error);
@@ -1726,12 +1789,12 @@ void RlsLb::RlsRequest::OnRlsCallCompleteLocked(grpc_error_handle error) {
             "[rlslb %p] rls_request=%p %s, error=%s, status={%d, %s} RLS call "
             "response received",
             lb_policy_.get(), this, key_.ToString().c_str(),
-            grpc_error_std_string(error).c_str(), status_recv_,
+            StatusToString(error).c_str(), status_recv_,
             status_message.c_str());
   }
   // Parse response.
   ResponseInfo response;
-  if (error != GRPC_ERROR_NONE) {
+  if (!error.ok()) {
     grpc_status_code code;
     std::string message;
     grpc_error_get_status(error, deadline_, &code, &message,
@@ -1749,7 +1812,7 @@ void RlsLb::RlsRequest::OnRlsCallCompleteLocked(grpc_error_handle error) {
   grpc_byte_buffer_destroy(recv_message_);
   grpc_metadata_array_destroy(&recv_initial_metadata_);
   grpc_metadata_array_destroy(&recv_trailing_metadata_);
-  grpc_slice_unref_internal(status_details_recv_);
+  CSliceUnref(status_details_recv_);
   grpc_call_unref(call_);
   call_ = nullptr;
   // Return result to cache.
@@ -1762,7 +1825,7 @@ void RlsLb::RlsRequest::OnRlsCallCompleteLocked(grpc_error_handle error) {
   {
     MutexLock lock(&lb_policy_->mu_);
     if (lb_policy_->is_shutdown_) return;
-    rls_channel_->ReportResponseLocked(!response.status.ok());
+    rls_channel_->ReportResponseLocked(response.status.ok());
     Cache::Entry* cache_entry = lb_policy_->cache_.FindOrInsert(key_);
     child_policies_to_finish_update = cache_entry->OnRlsResponseLocked(
         std::move(response), std::move(backoff_state_));
@@ -1771,7 +1834,9 @@ void RlsLb::RlsRequest::OnRlsCallCompleteLocked(grpc_error_handle error) {
   // Now that we've released the lock, finish the update on any newly
   // created child policies.
   for (ChildPolicyWrapper* child : child_policies_to_finish_update) {
-    child->MaybeFinishUpdate();
+    // TODO(roth): If the child reports an error with the update, we
+    // need to propagate that back to the resolver somehow.
+    (void)child->MaybeFinishUpdate();
   }
 }
 
@@ -1780,24 +1845,25 @@ grpc_byte_buffer* RlsLb::RlsRequest::MakeRequestProto() {
   grpc_lookup_v1_RouteLookupRequest* req =
       grpc_lookup_v1_RouteLookupRequest_new(arena.ptr());
   grpc_lookup_v1_RouteLookupRequest_set_target_type(
-      req, upb_strview_make(kGrpc, sizeof(kGrpc) - 1));
+      req, upb_StringView_FromDataAndSize(kGrpc, sizeof(kGrpc) - 1));
   for (const auto& kv : key_.key_map) {
     grpc_lookup_v1_RouteLookupRequest_key_map_set(
-        req, upb_strview_make(kv.first.data(), kv.first.size()),
-        upb_strview_make(kv.second.data(), kv.second.size()), arena.ptr());
+        req, upb_StringView_FromDataAndSize(kv.first.data(), kv.first.size()),
+        upb_StringView_FromDataAndSize(kv.second.data(), kv.second.size()),
+        arena.ptr());
   }
   grpc_lookup_v1_RouteLookupRequest_set_reason(req, reason_);
   if (!stale_header_data_.empty()) {
     grpc_lookup_v1_RouteLookupRequest_set_stale_header_data(
-        req,
-        upb_strview_make(stale_header_data_.data(), stale_header_data_.size()));
+        req, upb_StringView_FromDataAndSize(stale_header_data_.data(),
+                                            stale_header_data_.size()));
   }
   size_t len;
   char* buf =
       grpc_lookup_v1_RouteLookupRequest_serialize(req, arena.ptr(), &len);
   grpc_slice send_slice = grpc_slice_from_copied_buffer(buf, len);
   grpc_byte_buffer* byte_buffer = grpc_raw_byte_buffer_create(&send_slice, 1);
-  grpc_slice_unref_internal(send_slice);
+  CSliceUnref(send_slice);
   return byte_buffer;
 }
 
@@ -1812,13 +1878,13 @@ RlsLb::ResponseInfo RlsLb::RlsRequest::ParseResponseProto() {
       grpc_lookup_v1_RouteLookupResponse_parse(
           reinterpret_cast<const char*>(GRPC_SLICE_START_PTR(recv_slice)),
           GRPC_SLICE_LENGTH(recv_slice), arena.ptr());
-  grpc_slice_unref_internal(recv_slice);
+  CSliceUnref(recv_slice);
   if (response == nullptr) {
     response_info.status = absl::InternalError("cannot parse RLS response");
     return response_info;
   }
   size_t num_targets;
-  const upb_strview* targets_strview =
+  const upb_StringView* targets_strview =
       grpc_lookup_v1_RouteLookupResponse_targets(response, &num_targets);
   if (num_targets == 0) {
     response_info.status =
@@ -1830,7 +1896,7 @@ RlsLb::ResponseInfo RlsLb::RlsRequest::ParseResponseProto() {
     response_info.targets.emplace_back(targets_strview[i].data,
                                        targets_strview[i].size);
   }
-  upb_strview header_data_strview =
+  upb_StringView header_data_strview =
       grpc_lookup_v1_RouteLookupResponse_header_data(response);
   response_info.header_data =
       std::string(header_data_strview.data, header_data_strview.size);
@@ -1841,47 +1907,54 @@ RlsLb::ResponseInfo RlsLb::RlsRequest::ParseResponseProto() {
 // RlsLb
 //
 
-std::string GetServerUri(const grpc_channel_args* args) {
-  const char* server_uri_str =
-      grpc_channel_args_find_string(args, GRPC_ARG_SERVER_URI);
-  GPR_ASSERT(server_uri_str != nullptr);
-  absl::StatusOr<URI> uri = URI::Parse(server_uri_str);
+std::string GetServerUri(const ChannelArgs& args) {
+  auto server_uri_str = args.GetString(GRPC_ARG_SERVER_URI);
+  GPR_ASSERT(server_uri_str.has_value());
+  absl::StatusOr<URI> uri = URI::Parse(*server_uri_str);
   GPR_ASSERT(uri.ok());
   return std::string(absl::StripPrefix(uri->path(), "/"));
 }
 
 RlsLb::RlsLb(Args args)
     : LoadBalancingPolicy(std::move(args)),
-      server_name_(GetServerUri(args.args)),
+      server_name_(GetServerUri(channel_args())),
       cache_(this) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
     gpr_log(GPR_INFO, "[rlslb %p] policy created", this);
   }
 }
 
-void RlsLb::UpdateLocked(UpdateArgs args) {
+absl::Status RlsLb::UpdateLocked(UpdateArgs args) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
     gpr_log(GPR_INFO, "[rlslb %p] policy updated", this);
   }
-  // Swap out config, addresses, and channel args.
+  update_in_progress_ = true;
+  // Swap out config.
   RefCountedPtr<RlsLbConfig> old_config = std::move(config_);
   config_ = std::move(args.config);
-  ServerAddressList old_addresses = std::move(addresses_);
-  addresses_ = std::move(args.addresses);
-  grpc_channel_args_destroy(channel_args_);
-  channel_args_ = grpc_channel_args_copy(args.args);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace) &&
       (old_config == nullptr ||
        old_config->child_policy_config() != config_->child_policy_config())) {
     gpr_log(GPR_INFO, "[rlslb %p] updated child policy config: %s", this,
             config_->child_policy_config().Dump().c_str());
   }
+  // Swap out addresses.
+  // If the new address list is an error and we have an existing address list,
+  // stick with the existing addresses.
+  absl::StatusOr<ServerAddressList> old_addresses;
+  if (args.addresses.ok()) {
+    old_addresses = std::move(addresses_);
+    addresses_ = std::move(args.addresses);
+  } else {
+    old_addresses = addresses_;
+  }
+  // Swap out channel args.
+  channel_args_ = std::move(args.args);
   // Determine whether we need to update all child policies.
   bool update_child_policies =
       old_config == nullptr ||
       old_config->child_policy_config() != config_->child_policy_config() ||
-      old_addresses != addresses_ ||
-      grpc_channel_args_compare(args.args, channel_args_) != 0;
+      old_addresses != addresses_ || args.args != channel_args_;
   // If default target changes, swap out child policy.
   bool created_default_child = false;
   if (old_config == nullptr ||
@@ -1918,13 +1991,12 @@ void RlsLb::UpdateLocked(UpdateArgs args) {
     if (old_config == nullptr ||
         config_->lookup_service() != old_config->lookup_service()) {
       rls_channel_ =
-          MakeOrphanable<RlsChannel>(Ref(DEBUG_LOCATION, "RlsChannel"),
-                                     config_->lookup_service(), channel_args_);
+          MakeOrphanable<RlsChannel>(Ref(DEBUG_LOCATION, "RlsChannel"));
     }
     // Resize cache if needed.
     if (old_config == nullptr ||
         config_->cache_size_bytes() != old_config->cache_size_bytes()) {
-      cache_.Resize(config_->cache_size_bytes());
+      cache_.Resize(static_cast<size_t>(config_->cache_size_bytes()));
     }
     // Start update of child policies if needed.
     if (update_child_policies) {
@@ -1943,20 +2015,30 @@ void RlsLb::UpdateLocked(UpdateArgs args) {
     }
   }
   // Now that we've released the lock, finish update of child policies.
+  std::vector<std::string> errors;
   if (update_child_policies) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
       gpr_log(GPR_INFO, "[rlslb %p] finishing child policy updates", this);
     }
     for (auto& p : child_policy_map_) {
-      p.second->MaybeFinishUpdate();
+      absl::Status status = p.second->MaybeFinishUpdate();
+      if (!status.ok()) {
+        errors.emplace_back(
+            absl::StrCat("target ", p.first, ": ", status.ToString()));
+      }
     }
   } else if (created_default_child) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
       gpr_log(GPR_INFO, "[rlslb %p] finishing default child policy update",
               this);
     }
-    default_child_policy_->MaybeFinishUpdate();
+    absl::Status status = default_child_policy_->MaybeFinishUpdate();
+    if (!status.ok()) {
+      errors.emplace_back(absl::StrCat("target ", config_->default_target(),
+                                       ": ", status.ToString()));
+    }
   }
+  update_in_progress_ = false;
   // In principle, we need to update the picker here only if the config
   // fields used by the picker have changed.  However, it seems fragile
   // to check individual fields, since the picker logic could change in
@@ -1964,6 +2046,12 @@ void RlsLb::UpdateLocked(UpdateArgs args) {
   // remember to update the code here.  So for now, we just unconditionally
   // update the picker here, even though it's probably redundant.
   UpdatePickerLocked();
+  // Return status.
+  if (!errors.empty()) {
+    return absl::UnavailableError(absl::StrCat(
+        "errors from children: [", absl::StrJoin(errors, "; "), "]"));
+  }
+  return absl::OkStatus();
 }
 
 void RlsLb::ExitIdleLocked() {
@@ -1991,9 +2079,7 @@ void RlsLb::ShutdownLocked() {
   MutexLock lock(&mu_);
   is_shutdown_ = true;
   config_.reset(DEBUG_LOCATION, "ShutdownLocked");
-  if (channel_args_ != nullptr) {
-    grpc_channel_args_destroy(channel_args_);
-  }
+  channel_args_ = ChannelArgs();
   cache_.Shutdown();
   request_map_.clear();
   rls_channel_.reset();
@@ -2009,7 +2095,7 @@ void RlsLb::UpdatePickerAsync() {
       GRPC_CLOSURE_CREATE(UpdatePickerCallback,
                           Ref(DEBUG_LOCATION, "UpdatePickerCallback").release(),
                           grpc_schedule_on_exec_ctx),
-      GRPC_ERROR_NONE);
+      absl::OkStatus());
 }
 
 void RlsLb::UpdatePickerCallback(void* arg, grpc_error_handle /*error*/) {
@@ -2024,6 +2110,12 @@ void RlsLb::UpdatePickerCallback(void* arg, grpc_error_handle /*error*/) {
 }
 
 void RlsLb::UpdatePickerLocked() {
+  // If we're in the process of propagating an update from our parent to
+  // our children, ignore any updates that come from the children.  We
+  // will instead return a new picker once the update has been seen by
+  // all children.  This avoids unnecessary picker churn while an update
+  // is being propagated to our children.
+  if (update_in_progress_) return;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_lb_rls_trace)) {
     gpr_log(GPR_INFO, "[rlslb %p] updating picker", this);
   }
@@ -2069,434 +2161,366 @@ void RlsLb::UpdatePickerLocked() {
     status = absl::UnavailableError("no children available");
   }
   channel_control_helper()->UpdateState(
-      state, status, absl::make_unique<Picker>(Ref(DEBUG_LOCATION, "Picker")));
+      state, status, MakeRefCounted<Picker>(Ref(DEBUG_LOCATION, "Picker")));
 }
 
 //
 // RlsLbFactory
 //
 
-grpc_error_handle ParseJsonHeaders(size_t idx, const Json& json,
-                                   std::string* key,
-                                   std::vector<std::string>* headers) {
-  if (json.type() != Json::Type::OBJECT) {
-    return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
-        "field:headers index:", idx, " error:type should be OBJECT"));
-  }
-  std::vector<grpc_error_handle> error_list;
-  // requiredMatch must not be present.
-  if (json.object_value().find("requiredMatch") != json.object_value().end()) {
-    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:requiredMatch error:must not be present"));
-  }
-  // Find key.
-  if (ParseJsonObjectField(json.object_value(), "key", key, &error_list) &&
-      key->empty()) {
-    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:key error:must be non-empty"));
-  }
-  // Find headers.
-  const Json::Array* headers_json = nullptr;
-  ParseJsonObjectField(json.object_value(), "names", &headers_json,
-                       &error_list);
-  if (headers_json != nullptr) {
-    if (headers_json->empty()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:names error:list is empty"));
-    } else {
-      size_t name_idx = 0;
-      for (const Json& name_json : *headers_json) {
-        if (name_json.type() != Json::Type::STRING) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
-              "field:names index:", name_idx, " error:type should be STRING")));
-        } else if (name_json.string_value().empty()) {
-          error_list.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
-              absl::StrCat("field:names index:", name_idx,
-                           " error:header name must be non-empty")));
-        } else {
-          headers->push_back(name_json.string_value());
+struct GrpcKeyBuilder {
+  struct Name {
+    std::string service;
+    std::string method;
+
+    static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
+      static const auto* loader = JsonObjectLoader<Name>()
+                                      .Field("service", &Name::service)
+                                      .OptionalField("method", &Name::method)
+                                      .Finish();
+      return loader;
+    }
+  };
+
+  struct NameMatcher {
+    std::string key;
+    std::vector<std::string> names;
+    absl::optional<bool> required_match;
+
+    static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
+      static const auto* loader =
+          JsonObjectLoader<NameMatcher>()
+              .Field("key", &NameMatcher::key)
+              .Field("names", &NameMatcher::names)
+              .OptionalField("requiredMatch", &NameMatcher::required_match)
+              .Finish();
+      return loader;
+    }
+
+    void JsonPostLoad(const Json&, const JsonArgs&, ValidationErrors* errors) {
+      // key must be non-empty.
+      {
+        ValidationErrors::ScopedField field(errors, ".key");
+        if (!errors->FieldHasErrors() && key.empty()) {
+          errors->AddError("must be non-empty");
         }
-        ++name_idx;
       }
-    }
-  }
-  return GRPC_ERROR_CREATE_FROM_VECTOR_AND_CPP_STRING(
-      absl::StrCat("field:headers index:", idx), &error_list);
-}
-
-std::string ParseJsonMethodName(size_t idx, const Json& json,
-                                grpc_error_handle* error) {
-  if (json.type() != Json::Type::OBJECT) {
-    *error = GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
-        "field:names index:", idx, " error:type should be OBJECT"));
-    return "";
-  }
-  std::vector<grpc_error_handle> error_list;
-  // Find service name.
-  absl::string_view service_name;
-  ParseJsonObjectField(json.object_value(), "service", &service_name,
-                       &error_list);
-  // Find method name.
-  absl::string_view method_name;
-  ParseJsonObjectField(json.object_value(), "method", &method_name, &error_list,
-                       /*required=*/false);
-  // Return error, if any.
-  *error = GRPC_ERROR_CREATE_FROM_VECTOR_AND_CPP_STRING(
-      absl::StrCat("field:names index:", idx), &error_list);
-  // Construct path.
-  return absl::StrCat("/", service_name, "/", method_name);
-}
-
-grpc_error_handle ParseGrpcKeybuilder(
-    size_t idx, const Json& json, RlsLbConfig::KeyBuilderMap* key_builder_map) {
-  if (json.type() != Json::Type::OBJECT) {
-    return GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
-        "field:grpc_keybuilders index:", idx, " error:type should be OBJECT"));
-  }
-  std::vector<grpc_error_handle> error_list;
-  // Parse names.
-  std::set<std::string> names;
-  const Json::Array* names_array = nullptr;
-  if (ParseJsonObjectField(json.object_value(), "names", &names_array,
-                           &error_list)) {
-    if (names_array->empty()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:names error:list is empty"));
-    } else {
-      size_t name_idx = 0;
-      for (const Json& name_json : *names_array) {
-        grpc_error_handle child_error = GRPC_ERROR_NONE;
-        std::string name =
-            ParseJsonMethodName(name_idx++, name_json, &child_error);
-        if (child_error != GRPC_ERROR_NONE) {
-          error_list.push_back(child_error);
-        } else {
-          bool inserted = names.insert(name).second;
-          if (!inserted) {
-            error_list.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
-                absl::StrCat("field:names error:duplicate entry for ", name)));
+      // List of header names must be non-empty.
+      {
+        ValidationErrors::ScopedField field(errors, ".names");
+        if (!errors->FieldHasErrors() && names.empty()) {
+          errors->AddError("must be non-empty");
+        }
+        // Individual header names must be non-empty.
+        for (size_t i = 0; i < names.size(); ++i) {
+          ValidationErrors::ScopedField field(errors,
+                                              absl::StrCat("[", i, "]"));
+          if (!errors->FieldHasErrors() && names[i].empty()) {
+            errors->AddError("must be non-empty");
           }
         }
       }
-    }
-  }
-  // Helper function to check for duplicate keys.
-  std::set<std::string> all_keys;
-  auto duplicate_key_check_func = [&all_keys,
-                                   &error_list](const std::string& key) {
-    auto it = all_keys.find(key);
-    if (it != all_keys.end()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
-          absl::StrCat("key \"", key, "\" listed multiple times")));
-    } else {
-      all_keys.insert(key);
+      // requiredMatch must not be present.
+      {
+        ValidationErrors::ScopedField field(errors, ".requiredMatch");
+        if (required_match.has_value()) {
+          errors->AddError("must not be present");
+        }
+      }
     }
   };
-  // Parse headers.
-  RlsLbConfig::KeyBuilder key_builder;
-  const Json::Array* headers_array = nullptr;
-  ParseJsonObjectField(json.object_value(), "headers", &headers_array,
-                       &error_list, /*required=*/false);
-  if (headers_array != nullptr) {
-    size_t header_idx = 0;
-    for (const Json& header_json : *headers_array) {
-      std::string key;
-      std::vector<std::string> headers;
-      grpc_error_handle child_error =
-          ParseJsonHeaders(header_idx++, header_json, &key, &headers);
-      if (child_error != GRPC_ERROR_NONE) {
-        error_list.push_back(child_error);
-      } else {
-        duplicate_key_check_func(key);
-        key_builder.header_keys.emplace(key, std::move(headers));
-      }
+
+  struct ExtraKeys {
+    absl::optional<std::string> host_key;
+    absl::optional<std::string> service_key;
+    absl::optional<std::string> method_key;
+
+    static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
+      static const auto* loader =
+          JsonObjectLoader<ExtraKeys>()
+              .OptionalField("host", &ExtraKeys::host_key)
+              .OptionalField("service", &ExtraKeys::service_key)
+              .OptionalField("method", &ExtraKeys::method_key)
+              .Finish();
+      return loader;
+    }
+
+    void JsonPostLoad(const Json&, const JsonArgs&, ValidationErrors* errors) {
+      auto check_field = [&](const std::string& field_name,
+                             absl::optional<std::string>* struct_field) {
+        ValidationErrors::ScopedField field(errors,
+                                            absl::StrCat(".", field_name));
+        if (struct_field->has_value() && (*struct_field)->empty()) {
+          errors->AddError("must be non-empty if set");
+        }
+      };
+      check_field("host", &host_key);
+      check_field("service", &service_key);
+      check_field("method", &method_key);
     }
+  };
+
+  std::vector<Name> names;
+  std::vector<NameMatcher> headers;
+  ExtraKeys extra_keys;
+  std::map<std::string /*key*/, std::string /*value*/> constant_keys;
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&) {
+    static const auto* loader =
+        JsonObjectLoader<GrpcKeyBuilder>()
+            .Field("names", &GrpcKeyBuilder::names)
+            .OptionalField("headers", &GrpcKeyBuilder::headers)
+            .OptionalField("extraKeys", &GrpcKeyBuilder::extra_keys)
+            .OptionalField("constantKeys", &GrpcKeyBuilder::constant_keys)
+            .Finish();
+    return loader;
   }
-  // Parse extraKeys.
-  const Json::Object* extra_keys = nullptr;
-  ParseJsonObjectField(json.object_value(), "extraKeys", &extra_keys,
-                       &error_list, /*required=*/false);
-  if (extra_keys != nullptr) {
-    std::vector<grpc_error_handle> extra_keys_errors;
-    if (ParseJsonObjectField(*extra_keys, "host", &key_builder.host_key,
-                             &extra_keys_errors, /*required=*/false) &&
-        key_builder.host_key.empty()) {
-      extra_keys_errors.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:host error:must be non-empty"));
+
+  void JsonPostLoad(const Json&, const JsonArgs&, ValidationErrors* errors) {
+    // The names field must be non-empty.
+    {
+      ValidationErrors::ScopedField field(errors, ".names");
+      if (!errors->FieldHasErrors() && names.empty()) {
+        errors->AddError("must be non-empty");
+      }
     }
-    if (!key_builder.host_key.empty()) {
-      duplicate_key_check_func(key_builder.host_key);
+    // Make sure no key in constantKeys is empty.
+    if (constant_keys.find("") != constant_keys.end()) {
+      ValidationErrors::ScopedField field(errors, ".constantKeys[\"\"]");
+      errors->AddError("key must be non-empty");
     }
-    if (ParseJsonObjectField(*extra_keys, "service", &key_builder.service_key,
-                             &extra_keys_errors, /*required=*/false) &&
-        key_builder.service_key.empty()) {
-      extra_keys_errors.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:service error:must be non-empty"));
+    // Check for duplicate keys.
+    std::set<absl::string_view> keys_seen;
+    auto duplicate_key_check_func = [&keys_seen, errors](
+                                        const std::string& key,
+                                        const std::string& field_name) {
+      if (key.empty()) return;  // Already generated an error about this.
+      ValidationErrors::ScopedField field(errors, field_name);
+      auto it = keys_seen.find(key);
+      if (it != keys_seen.end()) {
+        errors->AddError(absl::StrCat("duplicate key \"", key, "\""));
+      } else {
+        keys_seen.insert(key);
+      }
+    };
+    for (size_t i = 0; i < headers.size(); ++i) {
+      NameMatcher& header = headers[i];
+      duplicate_key_check_func(header.key,
+                               absl::StrCat(".headers[", i, "].key"));
     }
-    if (!key_builder.service_key.empty()) {
-      duplicate_key_check_func(key_builder.service_key);
+    for (const auto& p : constant_keys) {
+      duplicate_key_check_func(
+          p.first, absl::StrCat(".constantKeys[\"", p.first, "\"]"));
     }
-    if (ParseJsonObjectField(*extra_keys, "method", &key_builder.method_key,
-                             &extra_keys_errors, /*required=*/false) &&
-        key_builder.method_key.empty()) {
-      extra_keys_errors.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:method error:must be non-empty"));
+    if (extra_keys.host_key.has_value()) {
+      duplicate_key_check_func(*extra_keys.host_key, ".extraKeys.host");
     }
-    if (!key_builder.method_key.empty()) {
-      duplicate_key_check_func(key_builder.method_key);
+    if (extra_keys.service_key.has_value()) {
+      duplicate_key_check_func(*extra_keys.service_key, ".extraKeys.service");
     }
-    if (!extra_keys_errors.empty()) {
-      error_list.push_back(
-          GRPC_ERROR_CREATE_FROM_VECTOR("field:extraKeys", &extra_keys_errors));
+    if (extra_keys.method_key.has_value()) {
+      duplicate_key_check_func(*extra_keys.method_key, ".extraKeys.method");
     }
   }
-  // Parse constantKeys.
-  const Json::Object* constant_keys = nullptr;
-  ParseJsonObjectField(json.object_value(), "constantKeys", &constant_keys,
-                       &error_list, /*required=*/false);
-  if (constant_keys != nullptr) {
-    std::vector<grpc_error_handle> constant_keys_errors;
-    for (const auto& p : *constant_keys) {
-      const std::string& key = p.first;
-      const Json& value = p.second;
-      if (key.empty()) {
-        constant_keys_errors.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "error:keys must be non-empty"));
+};
+
+const JsonLoaderInterface* RlsLbConfig::RouteLookupConfig::JsonLoader(
+    const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<RouteLookupConfig>()
+          // Note: Some fields require manual processing and are handled in
+          // JsonPostLoad() instead.
+          .Field("lookupService", &RouteLookupConfig::lookup_service)
+          .OptionalField("lookupServiceTimeout",
+                         &RouteLookupConfig::lookup_service_timeout)
+          .OptionalField("maxAge", &RouteLookupConfig::max_age)
+          .OptionalField("staleAge", &RouteLookupConfig::stale_age)
+          .Field("cacheSizeBytes", &RouteLookupConfig::cache_size_bytes)
+          .OptionalField("defaultTarget", &RouteLookupConfig::default_target)
+          .Finish();
+  return loader;
+}
+
+void RlsLbConfig::RouteLookupConfig::JsonPostLoad(const Json& json,
+                                                  const JsonArgs& args,
+                                                  ValidationErrors* errors) {
+  // Parse grpcKeybuilders.
+  auto grpc_keybuilders = LoadJsonObjectField<std::vector<GrpcKeyBuilder>>(
+      json.object_value(), args, "grpcKeybuilders", errors);
+  if (grpc_keybuilders.has_value()) {
+    ValidationErrors::ScopedField field(errors, ".grpcKeybuilders");
+    for (size_t i = 0; i < grpc_keybuilders->size(); ++i) {
+      ValidationErrors::ScopedField field(errors, absl::StrCat("[", i, "]"));
+      auto& grpc_keybuilder = (*grpc_keybuilders)[i];
+      // Construct KeyBuilder.
+      RlsLbConfig::KeyBuilder key_builder;
+      for (const auto& header : grpc_keybuilder.headers) {
+        key_builder.header_keys.emplace(header.key, header.names);
+      }
+      if (grpc_keybuilder.extra_keys.host_key.has_value()) {
+        key_builder.host_key = std::move(*grpc_keybuilder.extra_keys.host_key);
+      }
+      if (grpc_keybuilder.extra_keys.service_key.has_value()) {
+        key_builder.service_key =
+            std::move(*grpc_keybuilder.extra_keys.service_key);
+      }
+      if (grpc_keybuilder.extra_keys.method_key.has_value()) {
+        key_builder.method_key =
+            std::move(*grpc_keybuilder.extra_keys.method_key);
+      }
+      key_builder.constant_keys = std::move(grpc_keybuilder.constant_keys);
+      // Add entries to map.
+      for (const auto& name : grpc_keybuilder.names) {
+        std::string path = absl::StrCat("/", name.service, "/", name.method);
+        bool inserted = key_builder_map.emplace(path, key_builder).second;
+        if (!inserted) {
+          errors->AddError(absl::StrCat("duplicate entry for \"", path, "\""));
+        }
       }
-      duplicate_key_check_func(key);
-      ExtractJsonString(value, key, &key_builder.constant_keys[key],
-                        &constant_keys_errors);
-    }
-    if (!constant_keys_errors.empty()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_VECTOR(
-          "field:constantKeys", &constant_keys_errors));
-    }
-  }
-  // Insert key_builder into key_builder_map.
-  for (const std::string& name : names) {
-    bool inserted = key_builder_map->emplace(name, key_builder).second;
-    if (!inserted) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(
-          absl::StrCat("field:names error:duplicate entry for ", name)));
     }
   }
-  return GRPC_ERROR_CREATE_FROM_VECTOR_AND_CPP_STRING(
-      absl::StrCat("index:", idx), &error_list);
-}
-
-RlsLbConfig::KeyBuilderMap ParseGrpcKeybuilders(
-    const Json::Array& key_builder_list, grpc_error_handle* error) {
-  RlsLbConfig::KeyBuilderMap key_builder_map;
-  if (key_builder_list.empty()) {
-    *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:grpcKeybuilders error:list is empty");
-    return key_builder_map;
-  }
-  std::vector<grpc_error_handle> error_list;
-  size_t idx = 0;
-  for (const Json& key_builder : key_builder_list) {
-    grpc_error_handle child_error =
-        ParseGrpcKeybuilder(idx++, key_builder, &key_builder_map);
-    if (child_error != GRPC_ERROR_NONE) error_list.push_back(child_error);
-  }
-  *error = GRPC_ERROR_CREATE_FROM_VECTOR("field:grpcKeybuilders", &error_list);
-  return key_builder_map;
-}
-
-RlsLbConfig::RouteLookupConfig ParseRouteLookupConfig(
-    const Json::Object& json, grpc_error_handle* error) {
-  std::vector<grpc_error_handle> error_list;
-  RlsLbConfig::RouteLookupConfig route_lookup_config;
-  // Parse grpcKeybuilders.
-  const Json::Array* keybuilder_list = nullptr;
-  ParseJsonObjectField(json, "grpcKeybuilders", &keybuilder_list, &error_list);
-  if (keybuilder_list != nullptr) {
-    grpc_error_handle child_error = GRPC_ERROR_NONE;
-    route_lookup_config.key_builder_map =
-        ParseGrpcKeybuilders(*keybuilder_list, &child_error);
-    if (child_error != GRPC_ERROR_NONE) error_list.push_back(child_error);
-  }
-  // Parse lookupService.
-  if (ParseJsonObjectField(json, "lookupService",
-                           &route_lookup_config.lookup_service, &error_list)) {
-    if (!ResolverRegistry::IsValidTarget(route_lookup_config.lookup_service)) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:lookupService error:must be valid gRPC target URI"));
+  // Validate lookupService.
+  {
+    ValidationErrors::ScopedField field(errors, ".lookupService");
+    if (!errors->FieldHasErrors() &&
+        !CoreConfiguration::Get().resolver_registry().IsValidTarget(
+            lookup_service)) {
+      errors->AddError("must be valid gRPC target URI");
     }
   }
-  // Parse lookupServiceTimeout.
-  route_lookup_config.lookup_service_timeout = kDefaultLookupServiceTimeout;
-  ParseJsonObjectFieldAsDuration(json, "lookupServiceTimeout",
-                                 &route_lookup_config.lookup_service_timeout,
-                                 &error_list, /*required=*/false);
-  // Parse maxAge.
-  route_lookup_config.max_age = kMaxMaxAge;
-  bool max_age_set = ParseJsonObjectFieldAsDuration(
-      json, "maxAge", &route_lookup_config.max_age, &error_list,
-      /*required=*/false);
   // Clamp maxAge to the max allowed value.
-  if (route_lookup_config.max_age > kMaxMaxAge) {
-    route_lookup_config.max_age = kMaxMaxAge;
-  }
-  // Parse staleAge.
-  route_lookup_config.stale_age = kMaxMaxAge;
-  bool stale_age_set = ParseJsonObjectFieldAsDuration(
-      json, "staleAge", &route_lookup_config.stale_age, &error_list,
-      /*required=*/false);
+  if (max_age > kMaxMaxAge) max_age = kMaxMaxAge;
   // If staleAge is set, then maxAge must also be set.
-  if (stale_age_set && !max_age_set) {
-    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:maxAge error:must be set if staleAge is set"));
+  if (json.object_value().find("staleAge") != json.object_value().end() &&
+      json.object_value().find("maxAge") == json.object_value().end()) {
+    ValidationErrors::ScopedField field(errors, ".maxAge");
+    errors->AddError("must be set if staleAge is set");
   }
   // Ignore staleAge if greater than or equal to maxAge.
-  if (route_lookup_config.stale_age >= route_lookup_config.max_age) {
-    route_lookup_config.stale_age = route_lookup_config.max_age;
-  }
-  // Parse cacheSizeBytes.
-  ParseJsonObjectField(json, "cacheSizeBytes",
-                       &route_lookup_config.cache_size_bytes, &error_list);
-  if (route_lookup_config.cache_size_bytes <= 0) {
-    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:cacheSizeBytes error:must be greater than 0"));
+  if (stale_age >= max_age) stale_age = max_age;
+  // Validate cacheSizeBytes.
+  {
+    ValidationErrors::ScopedField field(errors, ".cacheSizeBytes");
+    if (!errors->FieldHasErrors() && cache_size_bytes <= 0) {
+      errors->AddError("must be greater than 0");
+    }
   }
   // Clamp cacheSizeBytes to the max allowed value.
-  if (route_lookup_config.cache_size_bytes > kMaxCacheSizeBytes) {
-    route_lookup_config.cache_size_bytes = kMaxCacheSizeBytes;
-  }
-  // Parse defaultTarget.
-  if (ParseJsonObjectField(json, "defaultTarget",
-                           &route_lookup_config.default_target, &error_list,
-                           /*required=*/false)) {
-    if (route_lookup_config.default_target.empty()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:defaultTarget error:must be non-empty if set"));
+  if (cache_size_bytes > kMaxCacheSizeBytes) {
+    cache_size_bytes = kMaxCacheSizeBytes;
+  }
+  // Validate defaultTarget.
+  {
+    ValidationErrors::ScopedField field(errors, ".defaultTarget");
+    if (!errors->FieldHasErrors() &&
+        json.object_value().find("defaultTarget") !=
+            json.object_value().end() &&
+        default_target.empty()) {
+      errors->AddError("must be non-empty if set");
     }
   }
-  *error =
-      GRPC_ERROR_CREATE_FROM_VECTOR("field:routeLookupConfig", &error_list);
-  return route_lookup_config;
-}
-
-grpc_error_handle ValidateChildPolicyList(
-    const Json& child_policy_list,
-    const std::string& child_policy_config_target_field_name,
-    const std::string& default_target, Json* child_policy_config,
-    RefCountedPtr<LoadBalancingPolicy::Config>*
-        default_child_policy_parsed_config) {
-  // Add target to each entry in the config proto.
-  *child_policy_config = child_policy_list;
-  std::string target =
-      default_target.empty() ? kFakeTargetFieldValue : default_target;
-  grpc_error_handle error = InsertOrUpdateChildPolicyField(
-      child_policy_config_target_field_name, target, child_policy_config);
-  if (error != GRPC_ERROR_NONE) return error;
-  // Parse the config.
-  RefCountedPtr<LoadBalancingPolicy::Config> parsed_config =
-      LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(
-          *child_policy_config, &error);
-  if (error != GRPC_ERROR_NONE) return error;
-  // Find the chosen config and return it in JSON form.
-  // We remove all non-selected configs, and in the selected config, we leave
-  // the target field in place, set to the default value.  This slightly
-  // optimizes what we need to do later when we update a child policy for a
-  // given target.
-  if (parsed_config != nullptr) {
-    for (Json& config : *(child_policy_config->mutable_array())) {
-      if (config.object_value().begin()->first == parsed_config->name()) {
-        Json save_config = std::move(config);
-        child_policy_config->mutable_array()->clear();
-        child_policy_config->mutable_array()->push_back(std::move(save_config));
-        break;
-      }
+}
+
+const JsonLoaderInterface* RlsLbConfig::JsonLoader(const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<RlsLbConfig>()
+          // Note: Some fields require manual processing and are handled in
+          // JsonPostLoad() instead.
+          .Field("routeLookupConfig", &RlsLbConfig::route_lookup_config_)
+          .Field("childPolicyConfigTargetFieldName",
+                 &RlsLbConfig::child_policy_config_target_field_name_)
+          .Finish();
+  return loader;
+}
+
+void RlsLbConfig::JsonPostLoad(const Json& json, const JsonArgs&,
+                               ValidationErrors* errors) {
+  // Parse routeLookupChannelServiceConfig.
+  auto it = json.object_value().find("routeLookupChannelServiceConfig");
+  if (it != json.object_value().end()) {
+    ValidationErrors::ScopedField field(errors,
+                                        ".routeLookupChannelServiceConfig");
+    // Don't need to save the result here, just need the errors (if any).
+    ServiceConfigImpl::Create(ChannelArgs(), it->second, errors);
+  }
+  // Validate childPolicyConfigTargetFieldName.
+  {
+    ValidationErrors::ScopedField field(errors,
+                                        ".childPolicyConfigTargetFieldName");
+    if (!errors->FieldHasErrors() &&
+        child_policy_config_target_field_name_.empty()) {
+      errors->AddError("must be non-empty");
     }
   }
-  // If default target is set, return the parsed config.
-  if (!default_target.empty()) {
-    *default_child_policy_parsed_config = std::move(parsed_config);
+  // Parse childPolicy.
+  {
+    ValidationErrors::ScopedField field(errors, ".childPolicy");
+    auto it = json.object_value().find("childPolicy");
+    if (it == json.object_value().end()) {
+      errors->AddError("field not present");
+    } else {
+      // Add target to all child policy configs in the list.
+      child_policy_config_ = it->second;
+      std::string target = route_lookup_config_.default_target.empty()
+                               ? kFakeTargetFieldValue
+                               : route_lookup_config_.default_target;
+      if (InsertOrUpdateChildPolicyField(child_policy_config_target_field_name_,
+                                         target, &child_policy_config_,
+                                         errors)) {
+        // Parse the config.
+        auto parsed_config =
+            CoreConfiguration::Get()
+                .lb_policy_registry()
+                .ParseLoadBalancingConfig(child_policy_config_);
+        if (!parsed_config.ok()) {
+          errors->AddError(parsed_config.status().message());
+        } else {
+          // Find the chosen config and return it in JSON form.
+          // We remove all non-selected configs, and in the selected config,
+          // we leave the target field in place, set to the default value.
+          // This slightly optimizes what we need to do later when we update
+          // a child policy for a given target.
+          for (Json& config : *(child_policy_config_.mutable_array())) {
+            if (config.object_value().begin()->first ==
+                (*parsed_config)->name()) {
+              Json save_config = std::move(config);
+              child_policy_config_.mutable_array()->clear();
+              child_policy_config_.mutable_array()->push_back(
+                  std::move(save_config));
+              break;
+            }
+          }
+          // If default target is set, set the default child config.
+          if (!route_lookup_config_.default_target.empty()) {
+            default_child_policy_parsed_config_ = std::move(*parsed_config);
+          }
+        }
+      }
+    }
   }
-  return GRPC_ERROR_NONE;
 }
 
 class RlsLbFactory : public LoadBalancingPolicyFactory {
  public:
-  const char* name() const override { return kRls; }
+  absl::string_view name() const override { return kRls; }
 
   OrphanablePtr<LoadBalancingPolicy> CreateLoadBalancingPolicy(
       LoadBalancingPolicy::Args args) const override {
     return MakeOrphanable<RlsLb>(std::move(args));
   }
 
-  RefCountedPtr<LoadBalancingPolicy::Config> ParseLoadBalancingConfig(
-      const Json& config, grpc_error_handle* error) const override {
-    std::vector<grpc_error_handle> error_list;
-    // Parse routeLookupConfig.
-    RlsLbConfig::RouteLookupConfig route_lookup_config;
-    const Json::Object* route_lookup_config_json = nullptr;
-    if (ParseJsonObjectField(config.object_value(), "routeLookupConfig",
-                             &route_lookup_config_json, &error_list)) {
-      grpc_error_handle child_error = GRPC_ERROR_NONE;
-      route_lookup_config =
-          ParseRouteLookupConfig(*route_lookup_config_json, &child_error);
-      if (child_error != GRPC_ERROR_NONE) error_list.push_back(child_error);
-    }
-    // Parse childPolicyConfigTargetFieldName.
-    std::string child_policy_config_target_field_name;
-    if (ParseJsonObjectField(
-            config.object_value(), "childPolicyConfigTargetFieldName",
-            &child_policy_config_target_field_name, &error_list)) {
-      if (child_policy_config_target_field_name.empty()) {
-        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:childPolicyConfigTargetFieldName error:must be non-empty"));
-      }
-    }
-    // Parse childPolicy.
-    Json child_policy_config;
-    RefCountedPtr<LoadBalancingPolicy::Config>
-        default_child_policy_parsed_config;
-    auto it = config.object_value().find("childPolicy");
-    if (it == config.object_value().end()) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:childPolicy error:does not exist."));
-    } else if (it->second.type() != Json::Type::ARRAY) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:childPolicy error:type should be ARRAY"));
-    } else {
-      grpc_error_handle child_error = ValidateChildPolicyList(
-          it->second, child_policy_config_target_field_name,
-          route_lookup_config.default_target, &child_policy_config,
-          &default_child_policy_parsed_config);
-      if (child_error != GRPC_ERROR_NONE) {
-        error_list.push_back(GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-            "field:childPolicy", &child_error, 1));
-        GRPC_ERROR_UNREF(child_error);
-      }
-    }
-    // Return result.
-    *error = GRPC_ERROR_CREATE_FROM_VECTOR(
-        "errors parsing RLS LB policy config", &error_list);
-    return MakeRefCounted<RlsLbConfig>(
-        std::move(route_lookup_config), std::move(child_policy_config),
-        std::move(child_policy_config_target_field_name),
-        std::move(default_child_policy_parsed_config));
+  absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
+  ParseLoadBalancingConfig(const Json& json) const override {
+    return LoadRefCountedFromJson<RlsLbConfig>(
+        json, JsonArgs(), "errors validing RLS LB policy config");
   }
 };
 
-bool RlsEnabled() {
-  char* value = gpr_getenv("GRPC_EXPERIMENTAL_ENABLE_RLS_LB_POLICY");
-  bool parsed_value;
-  bool parse_succeeded = gpr_parse_bool_value(value, &parsed_value);
-  gpr_free(value);
-  return parse_succeeded && parsed_value;
-}
-
 }  //  namespace
 
-void RlsLbPluginInit() {
-  if (!RlsEnabled()) return;
-  LoadBalancingPolicyRegistry::Builder::RegisterLoadBalancingPolicyFactory(
-      absl::make_unique<RlsLbFactory>());
+void RegisterRlsLbPolicy(CoreConfiguration::Builder* builder) {
+  builder->lb_policy_registry()->RegisterLoadBalancingPolicyFactory(
+      std::make_unique<RlsLbFactory>());
 }
 
-void RlsLbPluginShutdown() {}
-
 }  // namespace grpc_core