grpc 1.70.1 → 1.71.0

data/src/core/load_balancing/rls/rls.h

@@ -17,10 +17,106 @@
 #ifndef GRPC_SRC_CORE_LOAD_BALANCING_RLS_RLS_H
 #define GRPC_SRC_CORE_LOAD_BALANCING_RLS_RLS_H
 
-#include <grpc/support/port_platform.h>
+#include <map>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "src/core/load_balancing/lb_policy.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_object_loader.h"
+#include "src/core/util/time.h"
+#include "src/core/util/validation_errors.h"
 
 // A test-only channel arg to set the instance ID of the RLS LB
 // policy for use in metric labels.
 #define GRPC_ARG_TEST_ONLY_RLS_INSTANCE_ID "grpc.test-only.rls.instance_id"
 
+namespace grpc_core {
+
+// Parsed RLS LB policy configuration.
+class RlsLbConfig final : public LoadBalancingPolicy::Config {
+ public:
+  static constexpr Duration kMaxMaxAge = Duration::Minutes(5);
+
+  struct KeyBuilder {
+    std::map<std::string /*key*/, std::vector<std::string /*header*/>>
+        header_keys;
+    std::string host_key;
+    std::string service_key;
+    std::string method_key;
+    std::map<std::string /*key*/, std::string /*value*/> constant_keys;
+  };
+  using KeyBuilderMap = std::unordered_map<std::string /*path*/, KeyBuilder>;
+
+  RlsLbConfig() = default;
+
+  RlsLbConfig(const RlsLbConfig&) = delete;
+  RlsLbConfig& operator=(const RlsLbConfig&) = delete;
+
+  RlsLbConfig(RlsLbConfig&& other) = delete;
+  RlsLbConfig& operator=(RlsLbConfig&& other) = delete;
+
+  static absl::string_view Name() { return "rls_experimental"; }
+
+  absl::string_view name() const override { return Name(); }
+
+  const KeyBuilderMap& key_builder_map() const {
+    return route_lookup_config_.key_builder_map;
+  }
+  const std::string& lookup_service() const {
+    return route_lookup_config_.lookup_service;
+  }
+  Duration lookup_service_timeout() const {
+    return route_lookup_config_.lookup_service_timeout;
+  }
+  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_;
+  }
+  RefCountedPtr<LoadBalancingPolicy::Config>
+  default_child_policy_parsed_config() const {
+    return default_child_policy_parsed_config_;
+  }
+
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+  void JsonPostLoad(const Json& json, const JsonArgs&,
+                    ValidationErrors* errors);
+
+ private:
+  struct RouteLookupConfig {
+    KeyBuilderMap key_builder_map;
+    std::string lookup_service;
+    Duration lookup_service_timeout = Duration::Seconds(10);
+    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);
+  };
+
+  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>
+      default_child_policy_parsed_config_;
+};
+
+}  // namespace grpc_core
+
 #endif  // GRPC_SRC_CORE_LOAD_BALANCING_RLS_RLS_H

data/src/core/load_balancing/round_robin/round_robin.cc

@@ -22,6 +22,7 @@
 #include <algorithm>
 #include <atomic>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -34,7 +35,6 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
@@ -102,7 +102,7 @@ class RoundRobin final : public LoadBalancingPolicy {
 
      private:
       // Called when the child policy reports a connectivity state update.
-      void OnStateUpdate(absl::optional<grpc_connectivity_state> old_state,
+      void OnStateUpdate(std::optional<grpc_connectivity_state> old_state,
                          grpc_connectivity_state new_state,
                          const absl::Status& status) override;
     };
@@ -115,7 +115,7 @@ class RoundRobin final : public LoadBalancingPolicy {
     // Updates the counters of children in each state when a
     // child transitions from old_state to new_state.
     void UpdateStateCountersLocked(
-        absl::optional<grpc_connectivity_state> old_state,
+        std::optional<grpc_connectivity_state> old_state,
         grpc_connectivity_state new_state);
 
     // Ensures that the right child list is used and then updates
@@ -281,7 +281,7 @@ absl::Status RoundRobin::UpdateLocked(UpdateArgs args) {
 //
 
 void RoundRobin::RoundRobinEndpointList::RoundRobinEndpoint::OnStateUpdate(
-    absl::optional<grpc_connectivity_state> old_state,
+    std::optional<grpc_connectivity_state> old_state,
     grpc_connectivity_state new_state, const absl::Status& status) {
   auto* rr_endpoint_list = endpoint_list<RoundRobinEndpointList>();
   auto* round_robin = policy<RoundRobin>();
@@ -311,7 +311,7 @@ void RoundRobin::RoundRobinEndpointList::RoundRobinEndpoint::OnStateUpdate(
 //
 
 void RoundRobin::RoundRobinEndpointList::UpdateStateCountersLocked(
-    absl::optional<grpc_connectivity_state> old_state,
+    std::optional<grpc_connectivity_state> old_state,
     grpc_connectivity_state new_state) {
   // We treat IDLE the same as CONNECTING, since it will immediately
   // transition into that state anyway.

data/src/core/load_balancing/weighted_round_robin/static_stride_scheduler.cc

@@ -76,11 +76,11 @@ constexpr double kMinRatio = 0.01;
 
 }  // namespace
 
-absl::optional<StaticStrideScheduler> StaticStrideScheduler::Make(
+std::optional<StaticStrideScheduler> StaticStrideScheduler::Make(
     absl::Span<const float> float_weights,
     absl::AnyInvocable<uint32_t()> next_sequence_func) {
-  if (float_weights.empty()) return absl::nullopt;
-  if (float_weights.size() == 1) return absl::nullopt;
+  if (float_weights.empty()) return std::nullopt;
+  if (float_weights.size() == 1) return std::nullopt;
 
   // TODO(b/190488683): should we normalize negative weights to 0?
 
@@ -96,7 +96,7 @@ absl::optional<StaticStrideScheduler> StaticStrideScheduler::Make(
     }
   }
 
-  if (num_zero_weight_channels == n) return absl::nullopt;
+  if (num_zero_weight_channels == n) return std::nullopt;
 
   // Mean of non-zero weights before scaling to `kMaxWeight`.
   const double unscaled_mean =

data/src/core/load_balancing/weighted_round_robin/static_stride_scheduler.h

@@ -21,10 +21,10 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <optional>
 #include <vector>
 
 #include "absl/functional/any_invocable.h"
-#include "absl/types/optional.h"
 #include "absl/types/span.h"
 
 namespace grpc_core {
@@ -46,7 +46,7 @@ class StaticStrideScheduler final {
   // number, which may wrap. `float_weights` does not need to live beyond the
   // function. Caller is responsible for ensuring `next_sequence_func` remains
   // valid for all calls to `Pick()`.
-  static absl::optional<StaticStrideScheduler> Make(
+  static std::optional<StaticStrideScheduler> Make(
       absl::Span<const float> float_weights,
       absl::AnyInvocable<uint32_t()> next_sequence_func);
 

data/src/core/load_balancing/weighted_round_robin/weighted_round_robin.cc

@@ -24,10 +24,12 @@
 #include <atomic>
 #include <map>
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
 #include <type_traits>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
@@ -40,8 +42,6 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
@@ -267,7 +267,7 @@ class WeightedRoundRobin final : public LoadBalancingPolicy {
           const ChannelArgs& args) override;
 
       // Called when the child policy reports a connectivity state update.
-      void OnStateUpdate(absl::optional<grpc_connectivity_state> old_state,
+      void OnStateUpdate(std::optional<grpc_connectivity_state> old_state,
                          grpc_connectivity_state new_state,
                          const absl::Status& status) override;
 
@@ -300,7 +300,7 @@ class WeightedRoundRobin final : public LoadBalancingPolicy {
     // Updates the counters of children in each state when a
     // child transitions from old_state to new_state.
     void UpdateStateCountersLocked(
-        absl::optional<grpc_connectivity_state> old_state,
+        std::optional<grpc_connectivity_state> old_state,
         grpc_connectivity_state new_state);
 
     // Ensures that the right child list is used and then updates
@@ -383,7 +383,7 @@ class WeightedRoundRobin final : public LoadBalancingPolicy {
         ABSL_GUARDED_BY(&scheduler_mu_);
 
     Mutex timer_mu_ ABSL_ACQUIRED_BEFORE(&scheduler_mu_);
-    absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+    std::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
         timer_handle_ ABSL_GUARDED_BY(&timer_mu_);
 
     // Used when falling back to RR.
@@ -582,7 +582,7 @@ WeightedRoundRobin::PickResult WeightedRoundRobin::Picker::Pick(PickArgs args) {
   auto result = endpoint_info.picker->Pick(args);
   // Collect per-call utilization data if needed.
   if (!config_->enable_oob_load_report()) {
-    auto* complete = absl::get_if<PickResult::Complete>(&result.result);
+    auto* complete = std::get_if<PickResult::Complete>(&result.result);
     if (complete != nullptr) {
       complete->subchannel_call_tracker =
           std::make_unique<SubchannelCallTracker>(
@@ -667,7 +667,6 @@ void WeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
       config_->weight_update_period(),
       [self = WeakRefAsSubclass<Picker>(),
        work_serializer = wrr_->work_serializer()]() mutable {
-        ApplicationCallbackExecCtx callback_exec_ctx;
         ExecCtx exec_ctx;
         {
           MutexLock lock(&self->timer_mu_);
@@ -678,11 +677,6 @@ void WeightedRoundRobin::Picker::BuildSchedulerAndStartTimerLocked() {
             self->BuildSchedulerAndStartTimerLocked();
           }
         }
-        if (!IsWorkSerializerDispatchEnabled()) {
-          // Release the picker ref inside the WorkSerializer.
-          work_serializer->Run([self = std::move(self)]() {}, DEBUG_LOCATION);
-          return;
-        }
         self.reset();
       });
 }
@@ -852,7 +846,7 @@ WeightedRoundRobin::WrrEndpointList::WrrEndpoint::CreateSubchannel(
 }
 
 void WeightedRoundRobin::WrrEndpointList::WrrEndpoint::OnStateUpdate(
-    absl::optional<grpc_connectivity_state> old_state,
+    std::optional<grpc_connectivity_state> old_state,
     grpc_connectivity_state new_state, const absl::Status& status) {
   auto* wrr_endpoint_list = endpoint_list<WrrEndpointList>();
   auto* wrr = policy<WeightedRoundRobin>();
@@ -899,7 +893,7 @@ void WeightedRoundRobin::WrrEndpointList::WrrEndpoint::OnStateUpdate(
 //
 
 void WeightedRoundRobin::WrrEndpointList::UpdateStateCountersLocked(
-    absl::optional<grpc_connectivity_state> old_state,
+    std::optional<grpc_connectivity_state> old_state,
     grpc_connectivity_state new_state) {
   // We treat IDLE the same as CONNECTING, since it will immediately
   // transition into that state anyway.

data/src/core/load_balancing/weighted_target/weighted_target.cc

@@ -25,6 +25,7 @@
 #include <cstdint>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -39,7 +40,6 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
@@ -200,7 +200,7 @@ class WeightedTargetLb final : public LoadBalancingPolicy {
       void OnTimerLocked();
 
       RefCountedPtr<WeightedChild> weighted_child_;
-      absl::optional<EventEngine::TaskHandle> timer_handle_;
+      std::optional<EventEngine::TaskHandle> timer_handle_;
     };
 
     // Methods for dealing with the child policy.
@@ -300,7 +300,7 @@ void WeightedTargetLb::ShutdownLocked() {
 }
 
 void WeightedTargetLb::ResetBackoffLocked() {
-  for (auto& p : targets_) p.second->ResetBackoffLocked();
+  for (auto& [_, child] : targets_) child->ResetBackoffLocked();
 }
 
 absl::Status WeightedTargetLb::UpdateLocked(UpdateArgs args) {
@@ -311,9 +311,7 @@ absl::Status WeightedTargetLb::UpdateLocked(UpdateArgs args) {
   // Update config.
   config_ = args.config.TakeAsSubclass<WeightedTargetLbConfig>();
   // Deactivate the targets not in the new config.
-  for (const auto& p : targets_) {
-    const std::string& name = p.first;
-    WeightedChild* child = p.second.get();
+  for (const auto& [name, child] : targets_) {
     if (config_->target_map().find(name) == config_->target_map().end()) {
       child->DeactivateLocked();
     }
@@ -322,9 +320,7 @@ absl::Status WeightedTargetLb::UpdateLocked(UpdateArgs args) {
   absl::StatusOr<HierarchicalAddressMap> address_map =
       MakeHierarchicalAddressMap(args.addresses);
   std::vector<std::string> errors;
-  for (const auto& p : config_->target_map()) {
-    const std::string& name = p.first;
-    const WeightedTargetLbConfig::ChildConfig& config = p.second;
+  for (const auto& [name, config] : config_->target_map()) {
     auto& target = targets_[name];
     // Create child if it does not already exist.
     if (target == nullptr) {
@@ -392,9 +388,7 @@ void WeightedTargetLb::UpdateStateLocked() {
   // the aggregated state.
   size_t num_connecting = 0;
   size_t num_idle = 0;
-  for (const auto& p : targets_) {
-    const std::string& child_name = p.first;
-    const WeightedChild* child = p.second.get();
+  for (const auto& [child_name, child] : targets_) {
     // Skip the targets that are not in the latest update.
     if (config_->target_map().find(child_name) == config_->target_map().end()) {
       continue;
@@ -471,13 +465,11 @@ WeightedTargetLb::WeightedChild::DelayedRemovalTimer::DelayedRemovalTimer(
       weighted_child_->weighted_target_policy_->channel_control_helper()
           ->GetEventEngine()
           ->RunAfter(kChildRetentionInterval, [self = Ref()]() mutable {
-            ApplicationCallbackExecCtx app_exec_ctx;
             ExecCtx exec_ctx;
             auto* self_ptr = self.get();  // Avoid use-after-move problem.
             self_ptr->weighted_child_->weighted_target_policy_
                 ->work_serializer()
-                ->Run([self = std::move(self)] { self->OnTimerLocked(); },
-                      DEBUG_LOCATION);
+                ->Run([self = std::move(self)] { self->OnTimerLocked(); });
           });
 }
 

data/src/core/load_balancing/xds/cds.cc

@@ -22,10 +22,12 @@
 #include <algorithm>
 #include <map>
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
 #include <type_traits>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/log/check.h"
@@ -34,8 +36,6 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
@@ -240,9 +240,7 @@ class PriorityEndpointIterator final : public EndpointAddressesIterator {
       const auto& priority_entry = priority_list[priority];
       std::string priority_child_name =
           MakeChildPolicyName(cluster_name_, priority_child_numbers_[priority]);
-      for (const auto& p : priority_entry.localities) {
-        const auto& locality_name = p.first;
-        const auto& locality = p.second;
+      for (const auto& [locality_name, locality] : priority_entry.localities) {
         std::vector<RefCountedStringValue> hierarchical_path = {
             RefCountedStringValue(priority_child_name),
             locality_name->human_readable_string()};
@@ -348,7 +346,7 @@ absl::Status CdsLb::UpdateLocked(UpdateArgs args) {
       // Can't do this for an aggregate cluster, because even if the aggregate
       // cluster itself didn't change, the leaf clusters may have changed.
       if (*new_cluster_config == *old_cluster_config &&
-          absl::holds_alternative<XdsConfig::ClusterConfig::EndpointConfig>(
+          std::holds_alternative<XdsConfig::ClusterConfig::EndpointConfig>(
               new_cluster_config->children)) {
         return absl::OkStatus();
       }
@@ -359,7 +357,7 @@ absl::Status CdsLb::UpdateLocked(UpdateArgs args) {
   static constexpr absl::string_view kArgXdsAggregateClusterName =
       GRPC_ARG_NO_SUBCHANNEL_PREFIX "xds_aggregate_cluster_name";
   if (XdsAggregateClusterBackwardCompatibilityEnabled()) {
-    if (absl::holds_alternative<XdsConfig::ClusterConfig::EndpointConfig>(
+    if (std::holds_alternative<XdsConfig::ClusterConfig::EndpointConfig>(
             new_cluster_config->children)) {
       auto aggregate_cluster = args.args.GetString(kArgXdsAggregateClusterName);
       if (aggregate_cluster.has_value()) {
@@ -458,7 +456,7 @@ CdsLb::ChildNameState CdsLb::ComputeChildNames(
     const XdsConfig::ClusterConfig* old_cluster,
     const XdsConfig::ClusterConfig& new_cluster,
     const XdsConfig::ClusterConfig::EndpointConfig& endpoint_config) const {
-  CHECK(!absl::holds_alternative<XdsConfig::ClusterConfig::AggregateConfig>(
+  CHECK(!std::holds_alternative<XdsConfig::ClusterConfig::AggregateConfig>(
       new_cluster.children));
   // First, build some maps from locality to child number and the reverse
   // from old_cluster and child_name_state_.
@@ -468,7 +466,7 @@ CdsLb::ChildNameState CdsLb::ComputeChildNames(
       child_locality_map;
   if (old_cluster != nullptr) {
     auto* old_endpoint_config =
-        absl::get_if<XdsConfig::ClusterConfig::EndpointConfig>(
+        std::get_if<XdsConfig::ClusterConfig::EndpointConfig>(
             &old_cluster->children);
     if (old_endpoint_config != nullptr) {
       const auto& prev_priority_list =
@@ -478,8 +476,7 @@ CdsLb::ChildNameState CdsLb::ComputeChildNames(
         size_t child_number =
             child_name_state_.priority_child_numbers[priority];
         const auto& localities = prev_priority_list[priority].localities;
-        for (const auto& p : localities) {
-          XdsLocalityName* locality_name = p.first;
+        for (const auto& [locality_name, _] : localities) {
           locality_child_map[locality_name] = child_number;
           child_locality_map[child_number].insert(locality_name);
         }
@@ -495,11 +492,10 @@ CdsLb::ChildNameState CdsLb::ComputeChildNames(
       GetUpdatePriorityList(endpoint_config.endpoints.get());
   for (size_t priority = 0; priority < priority_list.size(); ++priority) {
     const auto& localities = priority_list[priority].localities;
-    absl::optional<size_t> child_number;
+    std::optional<size_t> child_number;
     // If one of the localities in this priority already existed, reuse its
     // child number.
-    for (const auto& p : localities) {
-      XdsLocalityName* locality_name = p.first;
+    for (const auto& [locality_name, _] : localities) {
       if (!child_number.has_value()) {
         auto it = locality_child_map.find(locality_name);
         if (it != locality_child_map.end()) {
@@ -542,7 +538,7 @@ Json CdsLb::CreateChildPolicyConfigForLeafCluster(
     const XdsClusterResource* aggregate_cluster_resource) {
   const auto& cluster_resource = *new_cluster.cluster;
   const bool is_logical_dns =
-      absl::holds_alternative<XdsClusterResource::LogicalDns>(
+      std::holds_alternative<XdsClusterResource::LogicalDns>(
           cluster_resource.type);
   // Determine what xDS LB policy to use.
   Json xds_lb_policy;

data/src/core/load_balancing/xds/xds_cluster_impl.cc

@@ -22,8 +22,10 @@
 #include <atomic>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
@@ -33,8 +35,6 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -191,7 +191,7 @@ class XdsClusterImplLb final : public LoadBalancingPolicy {
     // object, that object already contains the locality label.  We
     // need to store the locality label directly only in the case where
     // load reporting is disabled.
-    using LocalityData = absl::variant<
+    using LocalityData = std::variant<
         RefCountedStringValue /*locality*/,
         RefCountedPtr<LrsClient::ClusterLocalityStats> /*locality_stats*/>;
 
@@ -437,7 +437,7 @@ LoadBalancingPolicy::PickResult XdsClusterImplLb::Picker::Pick(
   }
   // Not dropping, so delegate to child picker.
   PickResult result = picker_->Pick(args);
-  auto* complete_pick = absl::get_if<PickResult::Complete>(&result.result);
+  auto* complete_pick = std::get_if<PickResult::Complete>(&result.result);
   if (complete_pick != nullptr) {
     auto* subchannel_wrapper =
         static_cast<StatsSubchannelWrapper*>(complete_pick->subchannel.get());
@@ -459,7 +459,7 @@ LoadBalancingPolicy::PickResult XdsClusterImplLb::Picker::Pick(
           call_state->GetCallAttribute<XdsRouteStateAttribute>();
       if (route_state_attribute != nullptr) {
         auto* route_action =
-            absl::get_if<XdsRouteConfigResource::Route::RouteAction>(
+            std::get_if<XdsRouteConfigResource::Route::RouteAction>(
                 &route_state_attribute->route().action);
         if (route_action != nullptr && route_action->auto_host_rewrite) {
           complete_pick->authority_override =
@@ -545,7 +545,7 @@ void XdsClusterImplLb::ResetBackoffLocked() {
 }
 
 std::string GetEdsResourceName(const XdsClusterResource& cluster_resource) {
-  auto* eds = absl::get_if<XdsClusterResource::Eds>(&cluster_resource.type);
+  auto* eds = std::get_if<XdsClusterResource::Eds>(&cluster_resource.type);
   if (eds == nullptr) return "";
   return eds->eds_service_name;
 }
@@ -580,9 +580,8 @@ absl::Status XdsClusterImplLb::UpdateLocked(UpdateArgs args) {
     return status;
   }
   auto& new_cluster_config = *it->second;
-  auto* endpoint_config =
-      absl::get_if<XdsConfig::ClusterConfig::EndpointConfig>(
-          &new_cluster_config.children);
+  auto* endpoint_config = std::get_if<XdsConfig::ClusterConfig::EndpointConfig>(
+      &new_cluster_config.children);
   if (endpoint_config == nullptr) {
     // Should never happen.
     absl::Status status = absl::InternalError(
@@ -684,7 +683,7 @@ XdsClusterImplLb::MaybeCreateCertificateProviderLocked(
   absl::Status status = Match(
       cluster_resource.common_tls_context.certificate_validation_context
           .ca_certs,
-      [](const absl::monostate&) {
+      [](const std::monostate&) {
         // No root cert configured.
         return absl::OkStatus();
       },
@@ -885,15 +884,13 @@ void XdsClusterImplLbConfig::JsonPostLoad(const Json& json, const JsonArgs&,
   auto it = json.object().find("childPolicy");
   if (it == json.object().end()) {
     errors->AddError("field not present");
+  } else if (auto lb_config = CoreConfiguration::Get()
+                                  .lb_policy_registry()
+                                  .ParseLoadBalancingConfig(it->second);
+             !lb_config.ok()) {
+    errors->AddError(lb_config.status().message());
   } else {
-    auto lb_config =
-        CoreConfiguration::Get().lb_policy_registry().ParseLoadBalancingConfig(
-            it->second);
-    if (!lb_config.ok()) {
-      errors->AddError(lb_config.status().message());
-    } else {
-      child_policy_ = std::move(*lb_config);
-    }
+    child_policy_ = std::move(*lb_config);
   }
 }
 

data/src/core/load_balancing/xds/xds_cluster_manager.cc

@@ -23,6 +23,7 @@
 #include <functional>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <type_traits>
 #include <utility>
@@ -34,7 +35,6 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -197,7 +197,7 @@ class XdsClusterManagerLb final : public LoadBalancingPolicy {
     grpc_connectivity_state connectivity_state_ = GRPC_CHANNEL_CONNECTING;
 
     // States for delayed removal.
-    absl::optional<EventEngine::TaskHandle> delayed_removal_timer_handle_;
+    std::optional<EventEngine::TaskHandle> delayed_removal_timer_handle_;
     bool shutdown_ = false;
   };
 
@@ -260,11 +260,11 @@ void XdsClusterManagerLb::ShutdownLocked() {
 }
 
 void XdsClusterManagerLb::ExitIdleLocked() {
-  for (auto& p : children_) p.second->ExitIdleLocked();
+  for (auto& [_, child] : children_) child->ExitIdleLocked();
 }
 
 void XdsClusterManagerLb::ResetBackoffLocked() {
-  for (auto& p : children_) p.second->ResetBackoffLocked();
+  for (auto& [_, child] : children_) child->ResetBackoffLocked();
 }
 
 absl::Status XdsClusterManagerLb::UpdateLocked(UpdateArgs args) {
@@ -275,18 +275,15 @@ absl::Status XdsClusterManagerLb::UpdateLocked(UpdateArgs args) {
   // Update config.
   config_ = args.config.TakeAsSubclass<XdsClusterManagerLbConfig>();
   // Deactivate the children not in the new config.
-  for (const auto& p : children_) {
-    const std::string& name = p.first;
-    ClusterChild* child = p.second.get();
+  for (const auto& [name, child] : children_) {
     if (config_->cluster_map().find(name) == config_->cluster_map().end()) {
       child->DeactivateLocked();
     }
   }
   // Add or update the children in the new config.
   std::vector<std::string> errors;
-  for (const auto& p : config_->cluster_map()) {
-    const std::string& name = p.first;
-    const RefCountedPtr<LoadBalancingPolicy::Config>& config = p.second.config;
+  for (const auto& [name, cluster] : config_->cluster_map()) {
+    const RefCountedPtr<LoadBalancingPolicy::Config>& config = cluster.config;
     auto& child = children_[name];
     if (child == nullptr) {
       child = MakeOrphanable<ClusterChild>(
@@ -322,9 +319,7 @@ void XdsClusterManagerLb::UpdateStateLocked() {
   size_t num_ready = 0;
   size_t num_connecting = 0;
   size_t num_idle = 0;
-  for (const auto& p : children_) {
-    const auto& child_name = p.first;
-    const ClusterChild* child = p.second.get();
+  for (const auto& [child_name, child] : children_) {
     // Skip the children that are not in the latest update.
     if (config_->cluster_map().find(child_name) ==
         config_->cluster_map().end()) {
@@ -365,8 +360,7 @@ void XdsClusterManagerLb::UpdateStateLocked() {
       << "[xds_cluster_manager_lb " << this << "] connectivity changed to "
       << ConnectivityStateName(connectivity_state);
   ClusterPicker::ClusterMap cluster_map;
-  for (const auto& p : config_->cluster_map()) {
-    const std::string& cluster_name = p.first;
+  for (const auto& [cluster_name, _] : config_->cluster_map()) {
     RefCountedPtr<SubchannelPicker>& child_picker = cluster_map[cluster_name];
     child_picker = children_[cluster_name]->picker();
     if (child_picker == nullptr) {
@@ -504,14 +498,12 @@ void XdsClusterManagerLb::ClusterChild::DeactivateLocked() {
           ->RunAfter(
               kChildRetentionInterval,
               [self = Ref(DEBUG_LOCATION, "ClusterChild+timer")]() mutable {
-                ApplicationCallbackExecCtx application_exec_ctx;
                 ExecCtx exec_ctx;
                 auto* self_ptr = self.get();  // Avoid use-after-move problem.
                 self_ptr->xds_cluster_manager_policy_->work_serializer()->Run(
                     [self = std::move(self)]() {
                       self->OnDelayedRemovalTimerLocked();
-                    },
-                    DEBUG_LOCATION);
+                    });
               });
 }