grpc 1.69.0 → 1.71.0

data/src/core/load_balancing/endpoint_list.h

@@ -22,18 +22,19 @@
 #include <stdlib.h>
 
 #include <memory>
+#include <optional>
 #include <utility>
 #include <vector>
 
 #include "absl/functional/function_ref.h"
 #include "absl/status/status.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/load_balancing/lb_policy.h"
 #include "src/core/load_balancing/subchannel_interface.h"
 #include "src/core/resolver/endpoint_addresses.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/down_cast.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/work_serializer.h"
@@ -51,9 +52,9 @@ class MyEndpointList : public EndpointList {
  public:
   MyEndpointList(RefCountedPtr<MyLbPolicy> lb_policy,
                  EndpointAddressesIterator* endpoints,
-                 const ChannelArgs& args,
+                 const ChannelArgs& args, std::string resolution_note,
                  std::vector<std::string>* errors)
-      : EndpointList(std::move(lb_policy),
+      : EndpointList(std::move(lb_policy), std::move(resolution_note),
                      GRPC_TRACE_FLAG_ENABLED(my_tracer)
                          ? "MyEndpointList"
                          : nullptr) {
@@ -83,7 +84,7 @@ class MyEndpointList : public EndpointList {
 
    private:
     void OnStateUpdate(
-        absl::optional<grpc_connectivity_state> old_state,
+        std::optional<grpc_connectivity_state> old_state,
         grpc_connectivity_state new_state,
         const absl::Status& status) override {
       // ...handle connectivity state change...
@@ -110,7 +111,7 @@ class EndpointList : public InternallyRefCounted<EndpointList> {
     void ResetBackoffLocked();
     void ExitIdleLocked();
 
-    absl::optional<grpc_connectivity_state> connectivity_state() const {
+    std::optional<grpc_connectivity_state> connectivity_state() const {
       return connectivity_state_;
     }
     RefCountedPtr<LoadBalancingPolicy::SubchannelPicker> picker() const {
@@ -132,7 +133,7 @@ class EndpointList : public InternallyRefCounted<EndpointList> {
     // down-casting in the caller.
     template <typename T>
     T* endpoint_list() const {
-      return static_cast<T*>(endpoint_list_.get());
+      return DownCast<T*>(endpoint_list_.get());
     }
 
     // Templated for convenience, to provide a short-hand for down-casting
@@ -150,9 +151,9 @@ class EndpointList : public InternallyRefCounted<EndpointList> {
     class Helper;
 
     // Called when the child policy reports a connectivity state update.
-    virtual void OnStateUpdate(
-        absl::optional<grpc_connectivity_state> old_state,
-        grpc_connectivity_state new_state, const absl::Status& status) = 0;
+    virtual void OnStateUpdate(std::optional<grpc_connectivity_state> old_state,
+                               grpc_connectivity_state new_state,
+                               const absl::Status& status) = 0;
 
     // Called to create a subchannel.  Subclasses may override.
     virtual RefCountedPtr<SubchannelInterface> CreateSubchannel(
@@ -162,7 +163,7 @@ class EndpointList : public InternallyRefCounted<EndpointList> {
     RefCountedPtr<EndpointList> endpoint_list_;
 
     OrphanablePtr<LoadBalancingPolicy> child_policy_;
-    absl::optional<grpc_connectivity_state> connectivity_state_;
+    std::optional<grpc_connectivity_state> connectivity_state_;
     RefCountedPtr<LoadBalancingPolicy::SubchannelPicker> picker_;
   };
 
@@ -181,12 +182,17 @@ class EndpointList : public InternallyRefCounted<EndpointList> {
 
   void ResetBackoffLocked();
 
+  void ReportTransientFailure(absl::Status status);
+
  protected:
   // We use two-phase initialization here to ensure that the vtable is
   // initialized before we need to use it.  Subclass must invoke Init()
   // from inside its ctor.
-  EndpointList(RefCountedPtr<LoadBalancingPolicy> policy, const char* tracer)
-      : policy_(std::move(policy)), tracer_(tracer) {}
+  EndpointList(RefCountedPtr<LoadBalancingPolicy> policy,
+               std::string resolution_note, const char* tracer)
+      : policy_(std::move(policy)),
+        resolution_note_(std::move(resolution_note)),
+        tracer_(tracer) {}
 
   void Init(EndpointAddressesIterator* endpoints, const ChannelArgs& args,
             absl::FunctionRef<OrphanablePtr<Endpoint>(
@@ -198,7 +204,7 @@ class EndpointList : public InternallyRefCounted<EndpointList> {
   // in the caller.
   template <typename T>
   T* policy() const {
-    return static_cast<T*>(policy_.get());
+    return DownCast<T*>(policy_.get());
   }
 
   // Returns true if all endpoints have seen their initial connectivity
@@ -214,6 +220,7 @@ class EndpointList : public InternallyRefCounted<EndpointList> {
       const = 0;
 
   RefCountedPtr<LoadBalancingPolicy> policy_;
+  std::string resolution_note_;
   const char* tracer_;
   std::vector<OrphanablePtr<Endpoint>> endpoints_;
   size_t num_endpoints_seen_initial_state_ = 0;

data/src/core/load_balancing/grpclb/client_load_reporting_filter.cc

@@ -22,10 +22,10 @@
 
 #include <functional>
 #include <memory>
+#include <optional>
 #include <type_traits>
 #include <utility>
 
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/map.h"
@@ -39,11 +39,6 @@
 
 namespace grpc_core {
 
-const NoInterceptor ClientLoadReportingFilter::Call::OnServerToClientMessage;
-const NoInterceptor ClientLoadReportingFilter::Call::OnClientToServerMessage;
-const NoInterceptor ClientLoadReportingFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor ClientLoadReportingFilter::Call::OnFinalize;
-
 const grpc_channel_filter ClientLoadReportingFilter::kFilter =
     MakePromiseBasedFilter<ClientLoadReportingFilter, FilterEndpoint::kClient,
                            kFilterExaminesServerInitialMetadata>();

data/src/core/load_balancing/grpclb/client_load_reporting_filter.h

@@ -43,10 +43,10 @@ class ClientLoadReportingFilter final
     void OnClientInitialMetadata(ClientMetadata& client_initial_metadata);
     void OnServerInitialMetadata(ServerMetadata& server_initial_metadata);
     void OnServerTrailingMetadata(ServerMetadata& server_trailing_metadata);
-    static const NoInterceptor OnServerToClientMessage;
-    static const NoInterceptor OnClientToServerMessage;
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnFinalize;
+    static inline const NoInterceptor OnServerToClientMessage;
+    static inline const NoInterceptor OnClientToServerMessage;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnFinalize;
 
    private:
     RefCountedPtr<GrpcLbClientStats> client_stats_;

data/src/core/load_balancing/grpclb/grpclb.cc

@@ -73,9 +73,11 @@
 #include <atomic>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <type_traits>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/container/inlined_vector.h"
@@ -89,8 +91,6 @@
 #include "absl/strings/str_format.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/channelz/channelz.h"
 #include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/config/core_configuration.h"
@@ -298,7 +298,7 @@ class GrpcLb final : public LoadBalancingPolicy {
     // Created after the first serverlist is received.
     RefCountedPtr<GrpcLbClientStats> client_stats_;
     Duration client_stats_report_interval_;
-    absl::optional<EventEngine::TaskHandle> client_load_report_handle_;
+    std::optional<EventEngine::TaskHandle> client_load_report_handle_;
     bool last_client_load_report_counters_were_zero_ = false;
     bool client_load_report_is_due_ = false;
     // The closure used for the completion of sending the load report.
@@ -323,20 +323,13 @@ class GrpcLb final : public LoadBalancingPolicy {
 
    private:
     void Orphaned() override {
-      if (!IsWorkSerializerDispatchEnabled()) {
-        if (!lb_policy_->shutting_down_) {
-          lb_policy_->CacheDeletedSubchannelLocked(wrapped_subchannel());
-        }
-        return;
-      }
       lb_policy_->work_serializer()->Run(
           [self = WeakRefAsSubclass<SubchannelWrapper>()]() {
             if (!self->lb_policy_->shutting_down_) {
               self->lb_policy_->CacheDeletedSubchannelLocked(
                   self->wrapped_subchannel());
             }
-          },
-          DEBUG_LOCATION);
+          });
     }
 
     RefCountedPtr<GrpcLb> lb_policy_;
@@ -570,7 +563,7 @@ class GrpcLb final : public LoadBalancingPolicy {
   const Duration lb_call_timeout_;
   // Balancer call retry state.
   BackOff lb_call_backoff_;
-  absl::optional<EventEngine::TaskHandle> lb_call_retry_timer_handle_;
+  std::optional<EventEngine::TaskHandle> lb_call_retry_timer_handle_;
 
   // The deserialized response from the balancer. May be nullptr until one
   // such response has arrived.
@@ -589,7 +582,7 @@ class GrpcLb final : public LoadBalancingPolicy {
   // we have not received a serverlist from the balancer.
   const Duration fallback_at_startup_timeout_;
   bool fallback_at_startup_checks_pending_ = false;
-  absl::optional<EventEngine::TaskHandle> lb_fallback_timer_handle_;
+  std::optional<EventEngine::TaskHandle> lb_fallback_timer_handle_;
 
   // The child policy to use for the backends.
   OrphanablePtr<LoadBalancingPolicy> child_policy_;
@@ -601,7 +594,7 @@ class GrpcLb final : public LoadBalancingPolicy {
   std::map<Timestamp /*deletion time*/,
            std::vector<RefCountedPtr<SubchannelInterface>>>
       cached_subchannels_;
-  absl::optional<EventEngine::TaskHandle> subchannel_cache_timer_handle_;
+  std::optional<EventEngine::TaskHandle> subchannel_cache_timer_handle_;
 };
 
 //
@@ -762,7 +755,7 @@ GrpcLb::PickResult GrpcLb::Picker::Pick(PickArgs args) {
   // Forward pick to child policy.
   PickResult result = child_picker_->Pick(args);
   // If pick succeeded, add LB token to initial metadata.
-  auto* complete_pick = absl::get_if<PickResult::Complete>(&result.result);
+  auto* complete_pick = std::get_if<PickResult::Complete>(&result.result);
   if (complete_pick != nullptr) {
     const SubchannelWrapper* subchannel_wrapper =
         static_cast<SubchannelWrapper*>(complete_pick->subchannel.get());
@@ -899,7 +892,7 @@ GrpcLb::BalancerCallState::BalancerCallState(
       /*parent_call=*/nullptr, GRPC_PROPAGATE_DEFAULTS,
       /*cq=*/nullptr, grpclb_policy_->interested_parties(),
       Slice::FromStaticString("/grpc.lb.v1.LoadBalancer/BalanceLoad"),
-      /*authority=*/absl::nullopt, deadline, /*registered_method=*/true);
+      /*authority=*/std::nullopt, deadline, /*registered_method=*/true);
   // Init the LB call request payload.
   upb::Arena arena;
   grpc_slice request_payload_slice = GrpcLbRequestCreate(
@@ -1021,10 +1014,9 @@ void GrpcLb::BalancerCallState::ScheduleNextClientLoadReportLocked() {
   client_load_report_handle_ =
       grpclb_policy()->channel_control_helper()->GetEventEngine()->RunAfter(
           client_stats_report_interval_, [this] {
-            ApplicationCallbackExecCtx callback_exec_ctx;
             ExecCtx exec_ctx;
             grpclb_policy()->work_serializer()->Run(
-                [this] { MaybeSendClientLoadReportLocked(); }, DEBUG_LOCATION);
+                [this] { MaybeSendClientLoadReportLocked(); });
           });
 }
 
@@ -1097,8 +1089,7 @@ void GrpcLb::BalancerCallState::ClientLoadReportDone(void* arg,
                                                      grpc_error_handle error) {
   BalancerCallState* lb_calld = static_cast<BalancerCallState*>(arg);
   lb_calld->grpclb_policy()->work_serializer()->Run(
-      [lb_calld, error]() { lb_calld->ClientLoadReportDoneLocked(error); },
-      DEBUG_LOCATION);
+      [lb_calld, error]() { lb_calld->ClientLoadReportDoneLocked(error); });
 }
 
 void GrpcLb::BalancerCallState::ClientLoadReportDoneLocked(
@@ -1116,7 +1107,7 @@ void GrpcLb::BalancerCallState::OnInitialRequestSent(
     void* arg, grpc_error_handle /*error*/) {
   BalancerCallState* lb_calld = static_cast<BalancerCallState*>(arg);
   lb_calld->grpclb_policy()->work_serializer()->Run(
-      [lb_calld]() { lb_calld->OnInitialRequestSentLocked(); }, DEBUG_LOCATION);
+      [lb_calld]() { lb_calld->OnInitialRequestSentLocked(); });
 }
 
 void GrpcLb::BalancerCallState::OnInitialRequestSentLocked() {
@@ -1135,8 +1126,7 @@ void GrpcLb::BalancerCallState::OnBalancerMessageReceived(
     void* arg, grpc_error_handle /*error*/) {
   BalancerCallState* lb_calld = static_cast<BalancerCallState*>(arg);
   lb_calld->grpclb_policy()->work_serializer()->Run(
-      [lb_calld]() { lb_calld->OnBalancerMessageReceivedLocked(); },
-      DEBUG_LOCATION);
+      [lb_calld]() { lb_calld->OnBalancerMessageReceivedLocked(); });
 }
 
 void GrpcLb::BalancerCallState::OnBalancerMessageReceivedLocked() {
@@ -1293,8 +1283,7 @@ void GrpcLb::BalancerCallState::OnBalancerStatusReceived(
     void* arg, grpc_error_handle error) {
   BalancerCallState* lb_calld = static_cast<BalancerCallState*>(arg);
   lb_calld->grpclb_policy()->work_serializer()->Run(
-      [lb_calld, error]() { lb_calld->OnBalancerStatusReceivedLocked(error); },
-      DEBUG_LOCATION);
+      [lb_calld, error]() { lb_calld->OnBalancerStatusReceivedLocked(error); });
 }
 
 void GrpcLb::BalancerCallState::OnBalancerStatusReceivedLocked(
@@ -1560,12 +1549,11 @@ absl::Status GrpcLb::UpdateLocked(UpdateArgs args) {
             fallback_at_startup_timeout_,
             [self = RefAsSubclass<GrpcLb>(DEBUG_LOCATION,
                                           "on_fallback_timer")]() mutable {
-              ApplicationCallbackExecCtx callback_exec_ctx;
               ExecCtx exec_ctx;
               auto self_ptr = self.get();
-              self_ptr->work_serializer()->Run(
-                  [self = std::move(self)]() { self->OnFallbackTimerLocked(); },
-                  DEBUG_LOCATION);
+              self_ptr->work_serializer()->Run([self = std::move(self)]() {
+                self->OnFallbackTimerLocked();
+              });
             });
     // Start watching the channel's connectivity state.  If the channel
     // goes into state TRANSIENT_FAILURE before the timer fires, we go into
@@ -1669,14 +1657,11 @@ void GrpcLb::StartBalancerCallRetryTimerLocked() {
           delay,
           [self = RefAsSubclass<GrpcLb>(
                DEBUG_LOCATION, "on_balancer_call_retry_timer")]() mutable {
-            ApplicationCallbackExecCtx callback_exec_ctx;
             ExecCtx exec_ctx;
             auto self_ptr = self.get();
-            self_ptr->work_serializer()->Run(
-                [self = std::move(self)]() {
-                  self->OnBalancerCallRetryTimerLocked();
-                },
-                DEBUG_LOCATION);
+            self_ptr->work_serializer()->Run([self = std::move(self)]() {
+              self->OnBalancerCallRetryTimerLocked();
+            });
           });
 }
 
@@ -1831,14 +1816,12 @@ void GrpcLb::StartSubchannelCacheTimerLocked() {
           cached_subchannels_.begin()->first - Timestamp::Now(),
           [self = RefAsSubclass<GrpcLb>(DEBUG_LOCATION,
                                         "OnSubchannelCacheTimer")]() mutable {
-            ApplicationCallbackExecCtx callback_exec_ctx;
             ExecCtx exec_ctx;
             auto* self_ptr = self.get();
             self_ptr->work_serializer()->Run(
                 [self = std::move(self)]() mutable {
                   self->OnSubchannelCacheTimerLocked();
-                },
-                DEBUG_LOCATION);
+                });
           });
 }
 

data/src/core/load_balancing/health_check_client.cc

@@ -24,6 +24,7 @@
 
 #include <map>
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
 #include <type_traits>
@@ -35,7 +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 "src/core/channelz/channel_trace.h"
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/client_channel/subchannel.h"
@@ -63,31 +63,6 @@
 
 namespace grpc_core {
 
-namespace {
-
-// A fire-and-forget class to asynchronously drain a WorkSerializer queue.
-class AsyncWorkSerializerDrainer final {
- public:
-  explicit AsyncWorkSerializerDrainer(
-      std::shared_ptr<WorkSerializer> work_serializer)
-      : work_serializer_(std::move(work_serializer)) {
-    GRPC_CLOSURE_INIT(&closure_, RunInExecCtx, this, nullptr);
-    ExecCtx::Run(DEBUG_LOCATION, &closure_, absl::OkStatus());
-  }
-
- private:
-  static void RunInExecCtx(void* arg, grpc_error_handle) {
-    auto* self = static_cast<AsyncWorkSerializerDrainer*>(arg);
-    self->work_serializer_->DrainQueue();
-    delete self;
-  }
-
-  std::shared_ptr<WorkSerializer> work_serializer_;
-  grpc_closure closure_;
-};
-
-}  // namespace
-
 //
 // HealthProducer::HealthChecker
 //
@@ -147,15 +122,12 @@ void HealthProducer::HealthChecker::NotifyWatchersLocked(
   GRPC_TRACE_LOG(health_check_client, INFO)
       << "HealthProducer " << producer_.get() << " HealthChecker " << this
       << ": reporting state " << ConnectivityStateName(state) << " to watchers";
-  work_serializer_->Schedule(
-      [self = Ref(), state, status = std::move(status)]() {
-        MutexLock lock(&self->producer_->mu_);
-        for (HealthWatcher* watcher : self->watchers_) {
-          watcher->Notify(state, status);
-        }
-      },
-      DEBUG_LOCATION);
-  new AsyncWorkSerializerDrainer(work_serializer_);
+  work_serializer_->Run([self = Ref(), state, status = std::move(status)]() {
+    MutexLock lock(&self->producer_->mu_);
+    for (HealthWatcher* watcher : self->watchers_) {
+      watcher->Notify(state, status);
+    }
+  });
 }
 
 void HealthProducer::HealthChecker::OnHealthWatchStatusChange(
@@ -168,7 +140,7 @@ void HealthProducer::HealthChecker::OnHealthWatchStatusChange(
         status.code(), absl::StrCat(producer_->subchannel_->address(), ": ",
                                     status.message()));
   }
-  work_serializer_->Schedule(
+  work_serializer_->Run(
       [self = Ref(), state, status = std::move(use_status)]() mutable {
         MutexLock lock(&self->producer_->mu_);
         if (self->stream_client_ != nullptr) {
@@ -178,9 +150,7 @@ void HealthProducer::HealthChecker::OnHealthWatchStatusChange(
             watcher->Notify(state, self->status_);
           }
         }
-      },
-      DEBUG_LOCATION);
-  new AsyncWorkSerializerDrainer(work_serializer_);
+      });
 }
 
 //
@@ -359,7 +329,7 @@ void HealthProducer::Orphaned() {
 
 void HealthProducer::AddWatcher(
     HealthWatcher* watcher,
-    const absl::optional<std::string>& health_check_service_name) {
+    const std::optional<std::string>& health_check_service_name) {
   MutexLock lock(&mu_);
   grpc_pollset_set_add_pollset_set(interested_parties_,
                                    watcher->interested_parties());
@@ -380,7 +350,7 @@ void HealthProducer::AddWatcher(
 
 void HealthProducer::RemoveWatcher(
     HealthWatcher* watcher,
-    const absl::optional<std::string>& health_check_service_name) {
+    const std::optional<std::string>& health_check_service_name) {
   MutexLock lock(&mu_);
   grpc_pollset_set_del_pollset_set(interested_parties_,
                                    watcher->interested_parties());
@@ -412,8 +382,8 @@ void HealthProducer::OnConnectivityStateChange(grpc_connectivity_state state,
   }
   state_ = state;
   status_ = status;
-  for (const auto& p : health_checkers_) {
-    p.second->OnConnectivityStateChangeLocked(state, status);
+  for (const auto& [_, health_checker] : health_checkers_) {
+    health_checker->OnConnectivityStateChangeLocked(state, status);
   }
   for (HealthWatcher* watcher : non_health_watchers_) {
     watcher->Notify(state, status);
@@ -466,12 +436,10 @@ void HealthWatcher::SetSubchannel(Subchannel* subchannel) {
 }
 
 void HealthWatcher::Notify(grpc_connectivity_state state, absl::Status status) {
-  work_serializer_->Schedule(
+  work_serializer_->Run(
       [watcher = watcher_, state, status = std::move(status)]() mutable {
         watcher->OnConnectivityStateChange(state, std::move(status));
-      },
-      DEBUG_LOCATION);
-  new AsyncWorkSerializerDrainer(work_serializer_);
+      });
 }
 
 //
@@ -483,7 +451,7 @@ MakeHealthCheckWatcher(
     std::shared_ptr<WorkSerializer> work_serializer, const ChannelArgs& args,
     std::unique_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
         watcher) {
-  absl::optional<std::string> health_check_service_name;
+  std::optional<std::string> health_check_service_name;
   if (!args.GetBool(GRPC_ARG_INHIBIT_HEALTH_CHECKING).value_or(false)) {
     health_check_service_name =
         args.GetOwnedString(GRPC_ARG_HEALTH_CHECK_SERVICE_NAME);

data/src/core/load_balancing/health_check_client_internal.h

@@ -22,6 +22,7 @@
 
 #include <map>
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
 #include <utility>
@@ -29,7 +30,6 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/client_channel/subchannel.h"
 #include "src/core/client_channel/subchannel_interface_internal.h"
 #include "src/core/client_channel/subchannel_stream_client.h"
@@ -65,10 +65,10 @@ class HealthProducer final : public Subchannel::DataProducerInterface {
   UniqueTypeName type() const override { return Type(); }
 
   void AddWatcher(HealthWatcher* watcher,
-                  const absl::optional<std::string>& health_check_service_name);
+                  const std::optional<std::string>& health_check_service_name);
   void RemoveWatcher(
       HealthWatcher* watcher,
-      const absl::optional<std::string>& health_check_service_name);
+      const std::optional<std::string>& health_check_service_name);
 
  private:
   class ConnectivityWatcher;
@@ -124,7 +124,7 @@ class HealthProducer final : public Subchannel::DataProducerInterface {
         std::make_shared<WorkSerializer>(
             producer_->subchannel_->event_engine());
 
-    absl::optional<grpc_connectivity_state> state_
+    std::optional<grpc_connectivity_state> state_
         ABSL_GUARDED_BY(&HealthProducer::mu_);
     absl::Status status_ ABSL_GUARDED_BY(&HealthProducer::mu_);
     OrphanablePtr<SubchannelStreamClient> stream_client_
@@ -142,7 +142,7 @@ class HealthProducer final : public Subchannel::DataProducerInterface {
   grpc_pollset_set* interested_parties_;
 
   Mutex mu_;
-  absl::optional<grpc_connectivity_state> state_ ABSL_GUARDED_BY(&mu_);
+  std::optional<grpc_connectivity_state> state_ ABSL_GUARDED_BY(&mu_);
   absl::Status status_ ABSL_GUARDED_BY(&mu_);
   RefCountedPtr<ConnectedSubchannel> connected_subchannel_
       ABSL_GUARDED_BY(&mu_);
@@ -157,7 +157,7 @@ class HealthWatcher final : public InternalSubchannelDataWatcherInterface {
  public:
   HealthWatcher(
       std::shared_ptr<WorkSerializer> work_serializer,
-      absl::optional<std::string> health_check_service_name,
+      std::optional<std::string> health_check_service_name,
       std::unique_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
           watcher)
       : work_serializer_(std::move(work_serializer)),
@@ -190,7 +190,7 @@ class HealthWatcher final : public InternalSubchannelDataWatcherInterface {
 
  private:
   std::shared_ptr<WorkSerializer> work_serializer_;
-  absl::optional<std::string> health_check_service_name_;
+  std::optional<std::string> health_check_service_name_;
   std::shared_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
       watcher_;
   RefCountedPtr<HealthProducer> producer_;

data/src/core/load_balancing/lb_policy.cc

@@ -79,12 +79,10 @@ LoadBalancingPolicy::PickResult LoadBalancingPolicy::QueuePicker::Pick(
                  GRPC_CLOSURE_CREATE(
                      [](void* arg, grpc_error_handle /*error*/) {
                        auto* parent = static_cast<LoadBalancingPolicy*>(arg);
-                       parent->work_serializer()->Run(
-                           [parent]() {
-                             parent->ExitIdleLocked();
-                             parent->Unref();
-                           },
-                           DEBUG_LOCATION);
+                       parent->work_serializer()->Run([parent]() {
+                         parent->ExitIdleLocked();
+                         parent->Unref();
+                       });
                      },
                      parent, nullptr),
                  absl::OkStatus());

data/src/core/load_balancing/lb_policy.h

@@ -26,16 +26,16 @@
 #include <stdint.h>
 
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
+#include <variant>
 
 #include "absl/base/thread_annotations.h"
 #include "absl/container/inlined_vector.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
-#include "absl/types/variant.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
@@ -115,7 +115,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
    public:
     virtual ~MetadataInterface() = default;
 
-    virtual absl::optional<absl::string_view> Lookup(
+    virtual std::optional<absl::string_view> Lookup(
         absl::string_view key, std::string* buffer) const = 0;
   };
 
@@ -152,14 +152,6 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     /// The LB policy may use the existing metadata to influence its routing
     /// decision, and it may add new metadata elements to be sent with the
     /// call to the chosen backend.
-    // TODO(roth): Before making the LB policy API public, consider
-    // whether this is the right way to expose metadata to the picker.
-    // This approach means that if a pick modifies metadata but then we
-    // discard the pick because the subchannel is not connected, the
-    // metadata change will still have been made.  Maybe we actually
-    // want to somehow provide metadata changes in PickResult::Complete
-    // instead?  Or maybe we use a CallTracer that can add metadata when
-    // the call actually starts on the subchannel?
     MetadataInterface* initial_metadata;
     /// An interface for accessing call state.  Can be used to allocate
     /// memory associated with the call in an efficient way.
@@ -261,7 +253,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
 
     // A pick result must be one of these types.
     // Default to Queue, just to allow default construction.
-    absl::variant<Complete, Queue, Fail, Drop> result = Queue();
+    std::variant<Complete, Queue, Fail, Drop> result = Queue();
 
     PickResult() = default;
     // NOLINTNEXTLINE(google-explicit-constructor)

data/src/core/load_balancing/lb_policy_registry.cc

@@ -108,15 +108,16 @@ LoadBalancingPolicyRegistry::ParseLoadBalancingConfigHelper(
       return absl::InvalidArgumentError("oneOf violation");
     }
     auto it = lb_config.object().begin();
-    if (it->second.type() != Json::Type::kObject) {
+    auto& [policy_name, config] = *it;
+    if (config.type() != Json::Type::kObject) {
       return absl::InvalidArgumentError("child entry should be of type object");
     }
     // If we support this policy, then select it.
-    if (LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
-            it->first.c_str(), nullptr)) {
+    if (LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(policy_name,
+                                                               nullptr)) {
       return it;
     }
-    policies_tried.push_back(it->first);
+    policies_tried.push_back(policy_name);
   }
   return absl::FailedPreconditionError(absl::StrCat(
       "No known policies in list: ", absl::StrJoin(policies_tried, " ")));
@@ -126,15 +127,16 @@ absl::StatusOr<RefCountedPtr<LoadBalancingPolicy::Config>>
 LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(const Json& json) const {
   auto policy = ParseLoadBalancingConfigHelper(json);
   if (!policy.ok()) return policy.status();
+  auto& [policy_name, config] = **policy;
   // Find factory.
   LoadBalancingPolicyFactory* factory =
-      GetLoadBalancingPolicyFactory((*policy)->first.c_str());
+      GetLoadBalancingPolicyFactory(policy_name);
   if (factory == nullptr) {
-    return absl::FailedPreconditionError(absl::StrFormat(
-        "Factory not found for policy \"%s\"", (*policy)->first));
+    return absl::FailedPreconditionError(
+        absl::StrFormat("Factory not found for policy \"%s\"", policy_name));
   }
   // Parse load balancing config via factory.
-  return factory->ParseLoadBalancingConfig((*policy)->second);
+  return factory->ParseLoadBalancingConfig(config);
 }
 
 }  // namespace grpc_core