grpc 1.70.1 → 1.71.0

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

@@ -25,11 +25,13 @@
 #include <functional>
 #include <map>
 #include <memory>
+#include <optional>
 #include <set>
 #include <string>
 #include <tuple>
 #include <type_traits>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
@@ -42,9 +44,7 @@
 #include "absl/strings/str_join.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "absl/types/span.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/ext/filters/stateful_session/stateful_session_filter.h"
@@ -211,7 +211,7 @@ class XdsOverrideHostLb final : public LoadBalancingPolicy {
    public:
     bool HasOwnedSubchannel() const
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsOverrideHostLb::mu_) {
-      auto* sc = absl::get_if<RefCountedPtr<SubchannelWrapper>>(&subchannel_);
+      auto* sc = std::get_if<RefCountedPtr<SubchannelWrapper>>(&subchannel_);
       return sc != nullptr && *sc != nullptr;
     }
 
@@ -298,7 +298,7 @@ class XdsOverrideHostLb final : public LoadBalancingPolicy {
    private:
     grpc_connectivity_state connectivity_state_
         ABSL_GUARDED_BY(&XdsOverrideHostLb::mu_) = GRPC_CHANNEL_IDLE;
-    absl::variant<SubchannelWrapper*, RefCountedPtr<SubchannelWrapper>>
+    std::variant<SubchannelWrapper*, RefCountedPtr<SubchannelWrapper>>
         subchannel_ ABSL_GUARDED_BY(&XdsOverrideHostLb::mu_);
     XdsHealthStatus eds_health_status_ ABSL_GUARDED_BY(
         &XdsOverrideHostLb::mu_) = XdsHealthStatus(XdsHealthStatus::kUnknown);
@@ -333,46 +333,17 @@ class XdsOverrideHostLb final : public LoadBalancingPolicy {
      private:
       static void RunInExecCtx(void* arg, grpc_error_handle /*error*/) {
         auto* self = static_cast<SubchannelConnectionRequester*>(arg);
-        self->subchannel_->policy()->work_serializer()->Run(
-            [self]() {
-              self->subchannel_->RequestConnection();
-              delete self;
-            },
-            DEBUG_LOCATION);
+        self->subchannel_->policy()->work_serializer()->Run([self]() {
+          self->subchannel_->RequestConnection();
+          delete self;
+        });
       }
 
       RefCountedPtr<SubchannelWrapper> subchannel_;
       grpc_closure closure_;
     };
 
-    class SubchannelCreationRequester final {
-     public:
-      SubchannelCreationRequester(RefCountedPtr<XdsOverrideHostLb> policy,
-                                  absl::string_view address)
-          : policy_(std::move(policy)), address_(address) {
-        GRPC_CLOSURE_INIT(&closure_, RunInExecCtx, this, nullptr);
-        // Hop into ExecCtx, so that we don't get stuck running
-        // arbitrary WorkSerializer callbacks while doing a pick.
-        ExecCtx::Run(DEBUG_LOCATION, &closure_, absl::OkStatus());
-      }
-
-     private:
-      static void RunInExecCtx(void* arg, grpc_error_handle /*error*/) {
-        auto* self = static_cast<SubchannelCreationRequester*>(arg);
-        self->policy_->work_serializer()->Run(
-            [self]() {
-              self->policy_->CreateSubchannelForAddress(self->address_);
-              delete self;
-            },
-            DEBUG_LOCATION);
-      }
-
-      RefCountedPtr<XdsOverrideHostLb> policy_;
-      std::string address_;
-      grpc_closure closure_;
-    };
-
-    absl::optional<LoadBalancingPolicy::PickResult> PickOverriddenHost(
+    std::optional<LoadBalancingPolicy::PickResult> PickOverriddenHost(
         XdsOverrideHostAttribute* override_host_attr) const;
 
     RefCountedPtr<XdsOverrideHostLb> policy_;
@@ -404,7 +375,7 @@ class XdsOverrideHostLb final : public LoadBalancingPolicy {
     void OnTimerLocked();
 
     RefCountedPtr<XdsOverrideHostLb> policy_;
-    absl::optional<EventEngine::TaskHandle> timer_handle_;
+    std::optional<EventEngine::TaskHandle> timer_handle_;
   };
 
   ~XdsOverrideHostLb() override;
@@ -467,12 +438,12 @@ XdsOverrideHostLb::Picker::Picker(
       << "] constructed new picker " << this;
 }
 
-absl::optional<LoadBalancingPolicy::PickResult>
+std::optional<LoadBalancingPolicy::PickResult>
 XdsOverrideHostLb::Picker::PickOverriddenHost(
     XdsOverrideHostAttribute* override_host_attr) const {
   CHECK_NE(override_host_attr, nullptr);
   auto cookie_address_list = override_host_attr->cookie_address_list();
-  if (cookie_address_list.empty()) return absl::nullopt;
+  if (cookie_address_list.empty()) return std::nullopt;
   // The cookie has an address list, so look through the addresses in order.
   absl::string_view address_with_no_subchannel;
   RefCountedPtr<SubchannelWrapper> idle_subchannel;
@@ -482,30 +453,32 @@ XdsOverrideHostLb::Picker::PickOverriddenHost(
     for (absl::string_view address : absl::StrSplit(cookie_address_list, ',')) {
       auto it = policy_->subchannel_map_.find(address);
       if (it == policy_->subchannel_map_.end()) continue;
+      auto& subchannel_entry = it->second;
       if (!override_host_health_status_set_.Contains(
-              it->second->eds_health_status())) {
+              subchannel_entry->eds_health_status())) {
         GRPC_TRACE_LOG(xds_override_host_lb, INFO)
             << "Subchannel " << address << " health status is not overridden ("
-            << it->second->eds_health_status().ToString() << ")";
+            << subchannel_entry->eds_health_status().ToString() << ")";
         continue;
       }
-      auto subchannel = it->second->GetSubchannelRef();
+      auto subchannel = subchannel_entry->GetSubchannelRef();
       if (subchannel == nullptr) {
         GRPC_TRACE_LOG(xds_override_host_lb, INFO)
             << "No subchannel for " << address;
         if (address_with_no_subchannel.empty()) {
-          address_with_no_subchannel = it->first;
+          address_with_no_subchannel = address;
         }
         continue;
       }
-      auto connectivity_state = it->second->connectivity_state();
+      auto connectivity_state = subchannel_entry->connectivity_state();
       if (connectivity_state == GRPC_CHANNEL_READY) {
         // Found a READY subchannel.  Pass back the actual address list
         // and return the subchannel.
         GRPC_TRACE_LOG(xds_override_host_lb, INFO)
             << "Picker override found READY subchannel " << address;
-        it->second->set_last_used_time();
-        override_host_attr->set_actual_address_list(it->second->address_list());
+        subchannel_entry->set_last_used_time();
+        override_host_attr->set_actual_address_list(
+            subchannel_entry->address_list());
         return PickResult::Complete(subchannel->wrapped_subchannel());
       } else if (connectivity_state == GRPC_CHANNEL_IDLE) {
         if (idle_subchannel == nullptr) idle_subchannel = std::move(subchannel);
@@ -536,20 +509,15 @@ XdsOverrideHostLb::Picker::PickOverriddenHost(
   if (!address_with_no_subchannel.empty()) {
     GRPC_TRACE_LOG(xds_override_host_lb, INFO)
         << "Picker override found entry with no subchannel";
-    if (!IsWorkSerializerDispatchEnabled()) {
-      new SubchannelCreationRequester(policy_, address_with_no_subchannel);
-    } else {
-      policy_->work_serializer()->Run(
-          [policy = policy_,
-           address = std::string(address_with_no_subchannel)]() {
-            policy->CreateSubchannelForAddress(address);
-          },
-          DEBUG_LOCATION);
-    }
+    policy_->work_serializer()->Run(
+        [policy = policy_,
+         address = std::string(address_with_no_subchannel)]() {
+          policy->CreateSubchannelForAddress(address);
+        });
     return PickResult::Queue();
   }
   // No entry found that was not in TRANSIENT_FAILURE.
-  return absl::nullopt;
+  return std::nullopt;
 }
 
 LoadBalancingPolicy::PickResult XdsOverrideHostLb::Picker::Pick(PickArgs args) {
@@ -568,7 +536,7 @@ LoadBalancingPolicy::PickResult XdsOverrideHostLb::Picker::Pick(PickArgs args) {
         "xds_override_host picker not given any child picker"));
   }
   auto 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* wrapper =
         static_cast<SubchannelWrapper*>(complete_pick->subchannel.get());
@@ -600,12 +568,10 @@ XdsOverrideHostLb::IdleTimer::IdleTimer(RefCountedPtr<XdsOverrideHostLb> policy,
       << ": subchannel cleanup pass will run in " << duration;
   timer_handle_ = policy_->channel_control_helper()->GetEventEngine()->RunAfter(
       duration, [self = RefAsSubclass<IdleTimer>()]() mutable {
-        ApplicationCallbackExecCtx callback_exec_ctx;
         ExecCtx exec_ctx;
         auto self_ptr = self.get();
         self_ptr->policy_->work_serializer()->Run(
-            [self = std::move(self)]() { self->OnTimerLocked(); },
-            DEBUG_LOCATION);
+            [self = std::move(self)]() { self->OnTimerLocked(); });
       });
 }
 
@@ -659,8 +625,8 @@ void XdsOverrideHostLb::ResetState() {
     std::vector<RefCountedPtr<SubchannelWrapper>> subchannel_refs_to_drop;
     MutexLock lock(&mu_);
     subchannel_refs_to_drop.reserve(subchannel_map_.size());
-    for (auto& p : subchannel_map_) {
-      p.second->UnsetSubchannel(&subchannel_refs_to_drop);
+    for (auto& [_, subchannel_entry] : subchannel_map_) {
+      subchannel_entry->UnsetSubchannel(&subchannel_refs_to_drop);
     }
     subchannel_map_.clear();
   }
@@ -886,9 +852,7 @@ void XdsOverrideHostLb::UpdateAddressMap(
         ++it;
       }
     }
-    for (auto& p : addresses_for_map) {
-      const auto& address = p.first;
-      auto& address_info = p.second;
+    for (auto& [address, address_info] : addresses_for_map) {
       auto it = subchannel_map_.find(address);
       if (it == subchannel_map_.end()) {
         GRPC_TRACE_LOG(xds_override_host_lb, INFO)
@@ -977,20 +941,20 @@ void XdsOverrideHostLb::CleanupSubchannels() {
   {
     MutexLock lock(&mu_);
     if (subchannel_map_.empty()) return;
-    for (const auto& p : subchannel_map_) {
-      if (p.second->last_used_time() <= idle_threshold) {
-        auto subchannel = p.second->TakeOwnedSubchannel();
+    for (const auto& [address, subchannel_entry] : subchannel_map_) {
+      if (subchannel_entry->last_used_time() <= idle_threshold) {
+        auto subchannel = subchannel_entry->TakeOwnedSubchannel();
         if (subchannel != nullptr) {
           GRPC_TRACE_LOG(xds_override_host_lb, INFO)
               << "[xds_override_host_lb " << this
-              << "] dropping subchannel for " << p.first;
+              << "] dropping subchannel for " << address;
           subchannel_refs_to_drop.push_back(std::move(subchannel));
         }
       } else {
         // Not dropping the subchannel.  Check the entry's last_used_time to
         // determine the next time at which the timer needs to run.
         const Duration next_time_for_entry =
-            p.second->last_used_time() + connection_idle_timeout_ - now;
+            subchannel_entry->last_used_time() + connection_idle_timeout_ - now;
         next_time = std::min(next_time, next_time_for_entry);
       }
     }
@@ -1060,15 +1024,6 @@ void XdsOverrideHostLb::SubchannelWrapper::Orphaned() {
   GRPC_TRACE_LOG(xds_override_host_lb, INFO)
       << "[xds_override_host_lb " << policy_.get() << "] subchannel wrapper "
       << this << " orphaned";
-  if (!IsWorkSerializerDispatchEnabled()) {
-    wrapped_subchannel()->CancelConnectivityStateWatch(watcher_);
-    if (subchannel_entry_ != nullptr) {
-      MutexLock lock(&policy()->mu_);
-      subchannel_entry_->OnSubchannelWrapperOrphan(
-          this, policy()->connection_idle_timeout_);
-    }
-    return;
-  }
   policy()->work_serializer()->Run(
       [self = WeakRefAsSubclass<SubchannelWrapper>()]() {
         self->wrapped_subchannel()->CancelConnectivityStateWatch(
@@ -1078,8 +1033,7 @@ void XdsOverrideHostLb::SubchannelWrapper::Orphaned() {
           self->subchannel_entry_->OnSubchannelWrapperOrphan(
               self.get(), self->policy()->connection_idle_timeout_);
         }
-      },
-      DEBUG_LOCATION);
+      });
 }
 
 void XdsOverrideHostLb::SubchannelWrapper::UpdateConnectivityState(
@@ -1236,15 +1190,14 @@ void XdsOverrideHostLbConfig::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 child_policy_config =
+                 CoreConfiguration::Get()
+                     .lb_policy_registry()
+                     .ParseLoadBalancingConfig(it->second);
+             !child_policy_config.ok()) {
+    errors->AddError(child_policy_config.status().message());
   } else {
-    auto child_policy_config =
-        CoreConfiguration::Get().lb_policy_registry().ParseLoadBalancingConfig(
-            it->second);
-    if (!child_policy_config.ok()) {
-      errors->AddError(child_policy_config.status().message());
-    } else {
-      child_config_ = std::move(*child_policy_config);
-    }
+    child_config_ = std::move(*child_policy_config);
   }
 }
 

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

@@ -21,6 +21,7 @@
 #include <cstdint>
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 
@@ -29,7 +30,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"
@@ -168,12 +168,12 @@ absl::Status XdsWrrLocalityLb::UpdateLocked(UpdateArgs args) {
       uint32_t weight =
           endpoint.args().GetInt(GRPC_ARG_XDS_LOCALITY_WEIGHT).value_or(0);
       if (locality_name != nullptr && weight > 0) {
-        auto p = locality_weights.emplace(
+        auto [it, inserted] = locality_weights.emplace(
             locality_name->human_readable_string(), weight);
-        if (!p.second && p.first->second != weight) {
+        if (!inserted && it->second != weight) {
           LOG(ERROR) << "INTERNAL ERROR: xds_wrr_locality found different "
                         "weights for locality "
-                     << p.first->first.c_str() << " (" << p.first->second
+                     << it->first.as_string_view() << " (" << it->second
                      << " vs " << weight << "); using first value";
         }
       }
@@ -181,14 +181,12 @@ absl::Status XdsWrrLocalityLb::UpdateLocked(UpdateArgs args) {
   }
   // Construct the config for the weighted_target policy.
   Json::Object weighted_targets;
-  for (const auto& p : locality_weights) {
-    absl::string_view locality_name = p.first.as_string_view();
-    uint32_t weight = p.second;
-    // Add weighted target entry.
-    weighted_targets[std::string(locality_name)] = Json::FromObject({
-        {"weight", Json::FromNumber(weight)},
-        {"childPolicy", config->child_config()},
-    });
+  for (const auto& [locality_name, weight] : locality_weights) {
+    weighted_targets[std::string(locality_name.as_string_view())] =
+        Json::FromObject({
+            {"weight", Json::FromNumber(weight)},
+            {"childPolicy", config->child_config()},
+        });
   }
   Json child_config_json = Json::FromArray({
       Json::FromObject({

data/src/core/resolver/dns/c_ares/dns_resolver_ares.cc

@@ -22,6 +22,7 @@
 #include <algorithm>
 #include <functional>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -33,7 +34,6 @@
 #include "absl/strings/match.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -162,7 +162,7 @@ class AresClientChannelDNSResolver final : public PollingResolver {
     static void OnHostnameResolved(void* arg, grpc_error_handle error);
     static void OnSRVResolved(void* arg, grpc_error_handle error);
     static void OnTXTResolved(void* arg, grpc_error_handle error);
-    absl::optional<Result> OnResolvedLocked(grpc_error_handle error)
+    std::optional<Result> OnResolvedLocked(grpc_error_handle error)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(on_resolved_mu_);
 
     Mutex on_resolved_mu_;
@@ -232,7 +232,7 @@ OrphanablePtr<Orphanable> AresClientChannelDNSResolver::StartRequest() {
 void AresClientChannelDNSResolver::AresRequestWrapper::OnHostnameResolved(
     void* arg, grpc_error_handle error) {
   auto* self = static_cast<AresRequestWrapper*>(arg);
-  absl::optional<Result> result;
+  std::optional<Result> result;
   {
     MutexLock lock(&self->on_resolved_mu_);
     self->hostname_request_.reset();
@@ -247,7 +247,7 @@ void AresClientChannelDNSResolver::AresRequestWrapper::OnHostnameResolved(
 void AresClientChannelDNSResolver::AresRequestWrapper::OnSRVResolved(
     void* arg, grpc_error_handle error) {
   auto* self = static_cast<AresRequestWrapper*>(arg);
-  absl::optional<Result> result;
+  std::optional<Result> result;
   {
     MutexLock lock(&self->on_resolved_mu_);
     self->srv_request_.reset();
@@ -262,7 +262,7 @@ void AresClientChannelDNSResolver::AresRequestWrapper::OnSRVResolved(
 void AresClientChannelDNSResolver::AresRequestWrapper::OnTXTResolved(
     void* arg, grpc_error_handle error) {
   auto* self = static_cast<AresRequestWrapper*>(arg);
-  absl::optional<Result> result;
+  std::optional<Result> result;
   {
     MutexLock lock(&self->on_resolved_mu_);
     self->txt_request_.reset();
@@ -278,7 +278,7 @@ void AresClientChannelDNSResolver::AresRequestWrapper::OnTXTResolved(
 // callers must release the lock and call OnRequestComplete if a Result is
 // returned. This is because OnRequestComplete may Orphan the resolver, which
 // requires taking the lock.
-absl::optional<AresClientChannelDNSResolver::Result>
+std::optional<AresClientChannelDNSResolver::Result>
 AresClientChannelDNSResolver::AresRequestWrapper::OnResolvedLocked(
     grpc_error_handle error) ABSL_EXCLUSIVE_LOCKS_REQUIRED(on_resolved_mu_) {
   if (hostname_request_ != nullptr || srv_request_ != nullptr ||
@@ -289,7 +289,7 @@ AresClientChannelDNSResolver::AresRequestWrapper::OnResolvedLocked(
         << (hostname_request_ != nullptr ? "waiting" : "done")
         << ", srv: " << (srv_request_ != nullptr ? "waiting" : "done")
         << ", txt: " << (txt_request_ != nullptr ? "waiting" : "done") << ")";
-    return absl::nullopt;
+    return std::nullopt;
   }
   GRPC_TRACE_VLOG(cares_resolver, 2)
       << "(c-ares resolver) resolver:" << this << " OnResolved() proceeding";

data/src/core/resolver/dns/event_engine/event_engine_client_channel_resolver.cc

@@ -22,6 +22,7 @@
 #include <algorithm>
 #include <chrono>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -35,7 +36,6 @@
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/strip.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/event_engine/resolved_address_internal.h"
@@ -116,7 +116,7 @@ class EventEngineClientChannelDNSResolver final : public PollingResolver {
     // callers must release the lock and call OnRequestComplete if a Result is
     // returned. This is because OnRequestComplete may Orphan the resolver,
     // which requires taking the lock.
-    absl::optional<Resolver::Result> OnResolvedLocked()
+    std::optional<Resolver::Result> OnResolvedLocked()
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(on_resolved_mu_);
     // Helper method to populate server addresses on resolver result.
     void MaybePopulateAddressesLocked(Resolver::Result* result)
@@ -146,7 +146,7 @@ class EventEngineClientChannelDNSResolver final : public PollingResolver {
     size_t number_of_balancer_hostnames_resolved_
         ABSL_GUARDED_BY(on_resolved_mu_) = 0;
     bool orphaned_ ABSL_GUARDED_BY(on_resolved_mu_) = false;
-    absl::optional<EventEngine::TaskHandle> timeout_handle_
+    std::optional<EventEngine::TaskHandle> timeout_handle_
         ABSL_GUARDED_BY(on_resolved_mu_);
     std::unique_ptr<EventEngine::DNSResolver> event_engine_resolver_;
   };
@@ -222,7 +222,6 @@ EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
       [self = Ref(DEBUG_LOCATION, "OnHostnameResolved")](
           absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
               addresses) mutable {
-        ApplicationCallbackExecCtx callback_exec_ctx;
         ExecCtx exec_ctx;
         self->OnHostnameResolved(std::move(addresses));
         self.reset();
@@ -238,7 +237,6 @@ EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
         [self = Ref(DEBUG_LOCATION, "OnSRVResolved")](
             absl::StatusOr<std::vector<EventEngine::DNSResolver::SRVRecord>>
                 srv_records) mutable {
-          ApplicationCallbackExecCtx callback_exec_ctx;
           ExecCtx exec_ctx;
           self->OnSRVResolved(std::move(srv_records));
           self.reset();
@@ -254,7 +252,6 @@ EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
     event_engine_resolver_->LookupTXT(
         [self = Ref(DEBUG_LOCATION, "OnTXTResolved")](
             absl::StatusOr<std::vector<std::string>> service_config) mutable {
-          ApplicationCallbackExecCtx callback_exec_ctx;
           ExecCtx exec_ctx;
           self->OnTXTResolved(std::move(service_config));
           self.reset();
@@ -267,7 +264,6 @@ EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
                      : resolver_->query_timeout_ms_;
   timeout_handle_ = resolver_->event_engine_->RunAfter(
       timeout, [self = Ref(DEBUG_LOCATION, "OnTimeout")]() mutable {
-        ApplicationCallbackExecCtx callback_exec_ctx;
         ExecCtx exec_ctx;
         self->OnTimeout();
         self.reset();
@@ -308,7 +304,7 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
 void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
     OnHostnameResolved(absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
                            new_addresses) {
-  absl::optional<Resolver::Result> result;
+  std::optional<Resolver::Result> result;
   {
     MutexLock lock(&on_resolved_mu_);
     // Make sure field destroys before cleanup.
@@ -334,7 +330,7 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
     OnSRVResolved(
         absl::StatusOr<std::vector<EventEngine::DNSResolver::SRVRecord>>
             srv_records) {
-  absl::optional<Resolver::Result> result;
+  std::optional<Resolver::Result> result;
   auto cleanup = absl::MakeCleanup([&]() {
     if (result.has_value()) {
       resolver_->OnRequestComplete(std::move(*result));
@@ -374,7 +370,6 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
          self = Ref(DEBUG_LOCATION, "OnBalancerHostnamesResolved")](
             absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
                 new_balancer_addresses) mutable {
-          ApplicationCallbackExecCtx callback_exec_ctx;
           ExecCtx exec_ctx;
           self->OnBalancerHostnamesResolved(std::move(host),
                                             std::move(new_balancer_addresses));
@@ -389,7 +384,7 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
         std::string authority,
         absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>
             new_balancer_addresses) {
-  absl::optional<Resolver::Result> result;
+  std::optional<Resolver::Result> result;
   auto cleanup = absl::MakeCleanup([&]() {
     if (result.has_value()) {
       resolver_->OnRequestComplete(std::move(*result));
@@ -420,7 +415,7 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
 
 void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
     OnTXTResolved(absl::StatusOr<std::vector<std::string>> service_config) {
-  absl::optional<Resolver::Result> result;
+  std::optional<Resolver::Result> result;
   {
     MutexLock lock(&on_resolved_mu_);
     // Make sure field destroys before cleanup.
@@ -503,9 +498,9 @@ void EventEngineClientChannelDNSResolver::EventEngineDNSRequestWrapper::
   }
 }
 
-absl::optional<Resolver::Result> EventEngineClientChannelDNSResolver::
+std::optional<Resolver::Result> EventEngineClientChannelDNSResolver::
     EventEngineDNSRequestWrapper::OnResolvedLocked() {
-  if (orphaned_) return absl::nullopt;
+  if (orphaned_) return std::nullopt;
   // Wait for all requested queries to return.
   if (is_hostname_inflight_ || is_srv_inflight_ || is_txt_inflight_ ||
       number_of_balancer_hostnames_resolved_ !=
@@ -518,7 +513,7 @@ absl::optional<Resolver::Result> EventEngineClientChannelDNSResolver::
         << ", txt: " << (is_txt_inflight_ ? "waiting" : "done")
         << ", balancer addresses: " << number_of_balancer_hostnames_resolved_
         << "/" << number_of_balancer_hostnames_initiated_ << " complete";
-    return absl::nullopt;
+    return std::nullopt;
   }
   GRPC_TRACE_VLOG(event_engine_client_channel_resolver, 2)
       << "(event_engine client channel resolver) DNSResolver::" << this

data/src/core/resolver/dns/native/dns_resolver.cc

@@ -19,6 +19,7 @@
 
 #include <algorithm>
 #include <memory>
+#include <optional>
 #include <utility>
 #include <vector>
 
@@ -29,7 +30,6 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/strip.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"

data/src/core/resolver/fake/fake_resolver.cc

@@ -62,7 +62,7 @@ class FakeResolver final : public Resolver {
   RefCountedPtr<FakeResolverResponseGenerator> response_generator_;
   // The next resolution result to be returned, if any.  Present when we
   // get a result before the resolver is started.
-  absl::optional<Result> next_result_;
+  std::optional<Result> next_result_;
   // True after the call to StartLocked().
   bool started_ = false;
   // True after the call to ShutdownLocked().
@@ -159,16 +159,15 @@ void FakeResolverResponseGenerator::SendResultToResolver(
     RefCountedPtr<FakeResolver> resolver, Resolver::Result result,
     Notification* notify_when_set) {
   auto* resolver_ptr = resolver.get();
-  resolver_ptr->work_serializer_->Run(
-      [resolver = std::move(resolver), result = std::move(result),
-       notify_when_set]() mutable {
-        if (!resolver->shutdown_) {
-          resolver->next_result_ = std::move(result);
-          resolver->MaybeSendResultLocked();
-        }
-        if (notify_when_set != nullptr) notify_when_set->Notify();
-      },
-      DEBUG_LOCATION);
+  resolver_ptr->work_serializer_->Run([resolver = std::move(resolver),
+                                       result = std::move(result),
+                                       notify_when_set]() mutable {
+    if (!resolver->shutdown_) {
+      resolver->next_result_ = std::move(result);
+      resolver->MaybeSendResultLocked();
+    }
+    if (notify_when_set != nullptr) notify_when_set->Notify();
+  });
 }
 
 bool FakeResolverResponseGenerator::WaitForResolverSet(absl::Duration timeout) {

data/src/core/resolver/fake/fake_resolver.h

@@ -20,12 +20,12 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
 #include "absl/strings/string_view.h"
 #include "absl/time/time.h"
-#include "absl/types/optional.h"
 #include "src/core/resolver/resolver.h"
 #include "src/core/util/notification.h"
 #include "src/core/util/ref_counted.h"
@@ -115,7 +115,7 @@ class FakeResolverResponseGenerator final
   RefCountedPtr<FakeResolver> resolver_ ABSL_GUARDED_BY(mu_);
   // Temporarily stores the result when it gets set before the response
   // generator is seen by the FakeResolver.
-  absl::optional<Resolver::Result> result_ ABSL_GUARDED_BY(mu_);
+  std::optional<Resolver::Result> result_ ABSL_GUARDED_BY(mu_);
 
   Mutex reresolution_mu_;
   CondVar* reresolution_cv_ ABSL_GUARDED_BY(reresolution_mu_) = nullptr;