grpc 1.70.1 → 1.71.0

data/src/core/client_channel/load_balanced_call_destination.cc

@@ -62,22 +62,22 @@ T HandlePickResult(
     std::function<T(LoadBalancingPolicy::PickResult::Fail*)> fail_func,
     std::function<T(LoadBalancingPolicy::PickResult::Drop*)> drop_func) {
   auto* complete_pick =
-      absl::get_if<LoadBalancingPolicy::PickResult::Complete>(&result->result);
+      std::get_if<LoadBalancingPolicy::PickResult::Complete>(&result->result);
   if (complete_pick != nullptr) {
     return complete_func(complete_pick);
   }
   auto* queue_pick =
-      absl::get_if<LoadBalancingPolicy::PickResult::Queue>(&result->result);
+      std::get_if<LoadBalancingPolicy::PickResult::Queue>(&result->result);
   if (queue_pick != nullptr) {
     return queue_func(queue_pick);
   }
   auto* fail_pick =
-      absl::get_if<LoadBalancingPolicy::PickResult::Fail>(&result->result);
+      std::get_if<LoadBalancingPolicy::PickResult::Fail>(&result->result);
   if (fail_pick != nullptr) {
     return fail_func(fail_pick);
   }
   auto* drop_pick =
-      absl::get_if<LoadBalancingPolicy::PickResult::Drop>(&result->result);
+      std::get_if<LoadBalancingPolicy::PickResult::Drop>(&result->result);
   CHECK(drop_pick != nullptr);
   return drop_func(drop_pick);
 }

data/src/core/client_channel/retry_filter.cc

@@ -19,11 +19,11 @@
 #include <grpc/event_engine/event_engine.h>
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <string>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/strip.h"
-#include "absl/types/optional.h"
 #include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/client_channel/retry_filter_legacy_call_data.h"
 #include "src/core/client_channel/retry_service_config.h"

data/src/core/client_channel/retry_filter.h

@@ -25,9 +25,9 @@
 #include <stddef.h>
 
 #include <new>
+#include <optional>
 
 #include "absl/log/check.h"
-#include "absl/types/optional.h"
 #include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/client_channel/retry_service_config.h"
 #include "src/core/client_channel/retry_throttle.h"

data/src/core/client_channel/retry_filter_legacy_call_data.cc

@@ -154,7 +154,6 @@ RetryFilter::LegacyCallData::CallAttempt::CallAttempt(
     Ref(DEBUG_LOCATION, "OnPerAttemptRecvTimer").release();
     per_attempt_recv_timer_handle_ = calld_->chand_->event_engine()->RunAfter(
         per_attempt_recv_timeout, [this] {
-          ApplicationCallbackExecCtx callback_exec_ctx;
           ExecCtx exec_ctx;
           OnPerAttemptRecvTimer();
         });
@@ -529,8 +528,8 @@ void RetryFilter::LegacyCallData::CallAttempt::CancelFromSurface(
 }
 
 bool RetryFilter::LegacyCallData::CallAttempt::ShouldRetry(
-    absl::optional<grpc_status_code> status,
-    absl::optional<Duration> server_pushback) {
+    std::optional<grpc_status_code> status,
+    std::optional<Duration> server_pushback) {
   // If no retry policy, don't retry.
   if (calld_->retry_policy_ == nullptr) return false;
   // Check status.
@@ -657,12 +656,12 @@ void RetryFilter::LegacyCallData::CallAttempt::OnPerAttemptRecvTimerLocked(
           StatusIntProperty::kRpcStatus, GRPC_STATUS_CANCELLED),
       &closures);
   // Check whether we should retry.
-  if (call_attempt->ShouldRetry(/*status=*/absl::nullopt,
-                                /*server_pushback_ms=*/absl::nullopt)) {
+  if (call_attempt->ShouldRetry(/*status=*/std::nullopt,
+                                /*server_pushback_ms=*/std::nullopt)) {
     // Mark current attempt as abandoned.
     call_attempt->Abandon();
     // We are retrying.  Start backoff timer.
-    calld->StartRetryTimer(/*server_pushback=*/absl::nullopt);
+    calld->StartRetryTimer(/*server_pushback=*/std::nullopt);
   } else {
     // Not retrying, so commit the call.
     calld->RetryCommit(call_attempt);
@@ -953,9 +952,9 @@ namespace {
 // and error.
 void GetCallStatus(
     Timestamp deadline, grpc_metadata_batch* md_batch, grpc_error_handle error,
-    grpc_status_code* status, absl::optional<Duration>* server_pushback,
+    grpc_status_code* status, std::optional<Duration>* server_pushback,
     bool* is_lb_drop,
-    absl::optional<GrpcStreamNetworkState::ValueType>* stream_network_state) {
+    std::optional<GrpcStreamNetworkState::ValueType>* stream_network_state) {
   if (!error.ok()) {
     grpc_error_get_status(error, deadline, status, nullptr, nullptr, nullptr);
     intptr_t value = 0;
@@ -1092,9 +1091,9 @@ void RetryFilter::LegacyCallData::CallAttempt::BatchData::
   call_attempt->MaybeCancelPerAttemptRecvTimer();
   // Get the call's status and check for server pushback metadata.
   grpc_status_code status = GRPC_STATUS_OK;
-  absl::optional<Duration> server_pushback;
+  std::optional<Duration> server_pushback;
   bool is_lb_drop = false;
-  absl::optional<GrpcStreamNetworkState::ValueType> stream_network_state;
+  std::optional<GrpcStreamNetworkState::ValueType> stream_network_state;
   grpc_metadata_batch* md_batch =
       batch_data->batch_.payload->recv_trailing_metadata.recv_trailing_metadata;
   GetCallStatus(calld->deadline_, md_batch, error, &status, &server_pushback,
@@ -1880,7 +1879,7 @@ void RetryFilter::LegacyCallData::RetryCommit(CallAttempt* call_attempt) {
 }
 
 void RetryFilter::LegacyCallData::StartRetryTimer(
-    absl::optional<Duration> server_pushback) {
+    std::optional<Duration> server_pushback) {
   // Reset call attempt.
   call_attempt_.reset(DEBUG_LOCATION, "StartRetryTimer");
   // Compute backoff delay.
@@ -1899,7 +1898,6 @@ void RetryFilter::LegacyCallData::StartRetryTimer(
   GRPC_CALL_STACK_REF(owning_call_, "OnRetryTimer");
   retry_timer_handle_ =
       chand_->event_engine()->RunAfter(next_attempt_timeout, [this] {
-        ApplicationCallbackExecCtx callback_exec_ctx;
         ExecCtx exec_ctx;
         OnRetryTimer();
       });

data/src/core/client_channel/retry_filter_legacy_call_data.h

@@ -22,11 +22,11 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <optional>
 #include <utility>
 
 #include "absl/container/inlined_vector.h"
 #include "absl/functional/any_invocable.h"
-#include "absl/types/optional.h"
 #include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/client_channel/retry_filter.h"
 #include "src/core/client_channel/retry_service_config.h"
@@ -241,8 +241,8 @@ class RetryFilter::LegacyCallData final {
     void MaybeSwitchToFastPath();
 
     // Returns true if the call should be retried.
-    bool ShouldRetry(absl::optional<grpc_status_code> status,
-                     absl::optional<Duration> server_pushback_ms);
+    bool ShouldRetry(std::optional<grpc_status_code> status,
+                     std::optional<Duration> server_pushback_ms);
 
     // Abandons the call attempt.  Unrefs any deferred batches.
     void Abandon();
@@ -256,7 +256,7 @@ class RetryFilter::LegacyCallData final {
     bool lb_call_committed_ = false;
 
     grpc_closure on_per_attempt_recv_timer_;
-    absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+    std::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
         per_attempt_recv_timer_handle_;
 
     // BatchData.batch.payload points to this.
@@ -273,7 +273,7 @@ class RetryFilter::LegacyCallData final {
     bool trailing_metadata_available_ = false;
     // For intercepting recv_message.
     grpc_closure recv_message_ready_;
-    absl::optional<SliceBuffer> recv_message_;
+    std::optional<SliceBuffer> recv_message_;
     uint32_t recv_message_flags_;
     // For intercepting recv_trailing_metadata.
     grpc_metadata_batch recv_trailing_metadata_;
@@ -352,7 +352,7 @@ class RetryFilter::LegacyCallData final {
 
   // Starts a timer to retry after appropriate back-off.
   // If server_pushback is nullopt, retry_backoff_ is used.
-  void StartRetryTimer(absl::optional<Duration> server_pushback);
+  void StartRetryTimer(std::optional<Duration> server_pushback);
 
   void OnRetryTimer();
   static void OnRetryTimerLocked(void* arg, grpc_error_handle /*error*/);
@@ -410,7 +410,7 @@ class RetryFilter::LegacyCallData final {
   bool retry_codepath_started_ : 1;
   bool sent_transparent_retry_not_seen_by_server_ : 1;
   int num_attempts_completed_ = 0;
-  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+  std::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
       retry_timer_handle_;
   grpc_closure retry_closure_;
 

data/src/core/client_channel/retry_interceptor.cc

@@ -55,14 +55,14 @@ RetryState::RetryState(
                                    ? Duration::Zero()
                                    : retry_policy_->max_backoff())) {}
 
-absl::optional<Duration> RetryState::ShouldRetry(
+std::optional<Duration> RetryState::ShouldRetry(
     const ServerMetadata& md, bool committed,
     absl::FunctionRef<std::string()> lazy_attempt_debug_string) {
   // If no retry policy, don't retry.
   if (retry_policy_ == nullptr) {
     GRPC_TRACE_LOG(retry, INFO)
         << lazy_attempt_debug_string() << " no retry policy";
-    return absl::nullopt;
+    return std::nullopt;
   }
   const auto status = md.get(GrpcStatusMetadata());
   if (status.has_value()) {
@@ -72,14 +72,14 @@ absl::optional<Duration> RetryState::ShouldRetry(
       }
       GRPC_TRACE_LOG(retry, INFO)
           << lazy_attempt_debug_string() << " call succeeded";
-      return absl::nullopt;
+      return std::nullopt;
     }
     // Status is not OK.  Check whether the status is retryable.
     if (!retry_policy_->retryable_status_codes().Contains(*status)) {
       GRPC_TRACE_LOG(retry, INFO) << lazy_attempt_debug_string() << ": status "
                                   << grpc_status_code_to_string(*status)
                                   << " not configured as retryable";
-      return absl::nullopt;
+      return std::nullopt;
     }
   }
   // Record the failure and check whether retries are throttled.
@@ -93,13 +93,13 @@ absl::optional<Duration> RetryState::ShouldRetry(
       !retry_throttle_data_->RecordFailure()) {
     GRPC_TRACE_LOG(retry, INFO)
         << lazy_attempt_debug_string() << " retries throttled";
-    return absl::nullopt;
+    return std::nullopt;
   }
   // Check whether the call is committed.
   if (committed) {
     GRPC_TRACE_LOG(retry, INFO)
         << lazy_attempt_debug_string() << " retries already committed";
-    return absl::nullopt;
+    return std::nullopt;
   }
   // Check whether we have retries remaining.
   ++num_attempts_completed_;
@@ -107,14 +107,14 @@ absl::optional<Duration> RetryState::ShouldRetry(
     GRPC_TRACE_LOG(retry, INFO)
         << lazy_attempt_debug_string() << " exceeded "
         << retry_policy_->max_attempts() << " retry attempts";
-    return absl::nullopt;
+    return std::nullopt;
   }
   // Check server push-back.
   const auto server_pushback = md.get(GrpcRetryPushbackMsMetadata());
   if (server_pushback.has_value() && server_pushback < Duration::Zero()) {
     GRPC_TRACE_LOG(retry, INFO) << lazy_attempt_debug_string()
                                 << " not retrying due to server push-back";
-    return absl::nullopt;
+    return std::nullopt;
   }
   // We should retry.
   Duration next_attempt_timeout;
@@ -298,8 +298,9 @@ auto RetryInterceptor::Attempt::ServerToClientGotInitialMetadata(
                              GRPC_TRACE_LOG(retry, INFO)
                                  << call->DebugTag() << " got server message "
                                  << message->DebugString();
-                             return call->call_handler()->SpawnPushMessage(
+                             call->call_handler()->SpawnPushMessage(
                                  std::move(message));
+                             return Success{};
                            }),
                    initiator_.PullServerTrailingMetadata(),
                    [call = call_](ServerMetadataHandle md) {
@@ -346,7 +347,7 @@ auto RetryInterceptor::Attempt::ServerToClientGotTrailersOnlyResponse() {
 auto RetryInterceptor::Attempt::ServerToClient() {
   return TrySeq(
       initiator_.PullServerInitialMetadata(),
-      [self = Ref()](absl::optional<ServerMetadataHandle> metadata) {
+      [self = Ref()](std::optional<ServerMetadataHandle> metadata) {
         const bool has_md = metadata.has_value();
         return If(
             has_md,
@@ -385,10 +386,11 @@ auto RetryInterceptor::Attempt::ClientToServer() {
         self->call_->call_handler()->AddChildCall(self->initiator_);
         self->initiator_.SpawnGuarded(
             "server_to_client", [self]() { return self->ServerToClient(); });
-        return ForEach(
-            MessagesFrom(&self->reader_), [self](MessageHandle message) {
-              return self->initiator_.SpawnPushMessage(std::move(message));
-            });
+        return ForEach(MessagesFrom(&self->reader_),
+                       [self](MessageHandle message) {
+                         self->initiator_.SpawnPushMessage(std::move(message));
+                         return Success{};
+                       });
       });
 }
 

data/src/core/client_channel/retry_interceptor.h

@@ -34,7 +34,7 @@ class RetryState {
 
   // if nullopt --> commit & don't retry
   // if duration --> retry after duration
-  absl::optional<Duration> ShouldRetry(
+  std::optional<Duration> ShouldRetry(
       const ServerMetadata& md, bool committed,
       absl::FunctionRef<std::string()> lazy_attempt_debug_string);
   int num_attempts_completed() const { return num_attempts_completed_; }
@@ -90,7 +90,7 @@ class RetryInterceptor : public Interceptor {
     RetryInterceptor* interceptor() { return interceptor_.get(); }
     // if nullopt --> commit & don't retry
     // if duration --> retry after duration
-    absl::optional<Duration> ShouldRetry(
+    std::optional<Duration> ShouldRetry(
         const ServerMetadata& md,
         absl::FunctionRef<std::string()> lazy_attempt_debug_string) {
       return retry_state_.ShouldRetry(md, request_buffer_.committed(),

data/src/core/client_channel/retry_service_config.cc

@@ -22,6 +22,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <map>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -29,7 +30,6 @@
 #include "absl/log/log.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.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/channel/status_util.h"

data/src/core/client_channel/retry_service_config.h

@@ -22,9 +22,9 @@
 #include <stdint.h>
 
 #include <memory>
+#include <optional>
 
 #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/channel/status_util.h"
@@ -61,7 +61,7 @@ class RetryMethodConfig final : public ServiceConfigParser::ParsedConfig {
   StatusCodeSet retryable_status_codes() const {
     return retryable_status_codes_;
   }
-  absl::optional<Duration> per_attempt_recv_timeout() const {
+  std::optional<Duration> per_attempt_recv_timeout() const {
     return per_attempt_recv_timeout_;
   }
 
@@ -88,7 +88,7 @@ class RetryMethodConfig final : public ServiceConfigParser::ParsedConfig {
   Duration max_backoff_;
   float backoff_multiplier_ = 0;
   StatusCodeSet retryable_status_codes_;
-  absl::optional<Duration> per_attempt_recv_timeout_;
+  std::optional<Duration> per_attempt_recv_timeout_;
 };
 
 class RetryServiceConfigParser final : public ServiceConfigParser::Parser {

data/src/core/client_channel/subchannel.cc

@@ -26,6 +26,7 @@
 #include <algorithm>
 #include <memory>
 #include <new>
+#include <optional>
 #include <utility>
 
 #include "absl/log/check.h"
@@ -34,7 +35,6 @@
 #include "absl/strings/cord.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/channelz/channelz.h"
 #include "src/core/client_channel/client_channel_internal.h"
@@ -431,8 +431,6 @@ class Subchannel::ConnectedSubchannelStateWatcher final
         c->backoff_.Reset();
       }
     }
-    // Drain any connectivity state notifications after releasing the mutex.
-    c->work_serializer_.DrainQueue();
   }
 
   WeakRefCountedPtr<Subchannel> subchannel_;
@@ -444,7 +442,7 @@ class Subchannel::ConnectedSubchannelStateWatcher final
 
 void Subchannel::ConnectivityStateWatcherList::AddWatcherLocked(
     RefCountedPtr<ConnectivityStateWatcherInterface> watcher) {
-  watchers_.insert(std::make_pair(watcher.get(), std::move(watcher)));
+  watchers_.insert(std::move(watcher));
 }
 
 void Subchannel::ConnectivityStateWatcherList::RemoveWatcherLocked(
@@ -454,14 +452,12 @@ void Subchannel::ConnectivityStateWatcherList::RemoveWatcherLocked(
 
 void Subchannel::ConnectivityStateWatcherList::NotifyLocked(
     grpc_connectivity_state state, const absl::Status& status) {
-  for (const auto& p : watchers_) {
-    subchannel_->work_serializer_.Schedule(
-        [watcher = p.second->Ref(), state, status]() mutable {
-          auto* watcher_ptr = watcher.get();
-          watcher_ptr->OnConnectivityStateChange(std::move(watcher), state,
-                                                 status);
-        },
-        DEBUG_LOCATION);
+  for (const auto& watcher : watchers_) {
+    subchannel_->work_serializer_.Run([watcher = watcher->Ref(), state,
+                                       status]() mutable {
+      auto* watcher_ptr = watcher.get();
+      watcher_ptr->OnConnectivityStateChange(std::move(watcher), state, status);
+    });
   }
 }
 
@@ -473,7 +469,7 @@ namespace {
 
 BackOff::Options ParseArgsForBackoffValues(const ChannelArgs& args,
                                            Duration* min_connect_timeout) {
-  const absl::optional<Duration> fixed_reconnect_backoff =
+  const std::optional<Duration> fixed_reconnect_backoff =
       args.GetDurationFromIntMillis("grpc.testing.fixed_reconnect_backoff_ms");
   if (fixed_reconnect_backoff.has_value()) {
     const Duration backoff =
@@ -611,50 +607,36 @@ channelz::SubchannelNode* Subchannel::channelz_node() {
 
 void Subchannel::WatchConnectivityState(
     RefCountedPtr<ConnectivityStateWatcherInterface> watcher) {
-  {
-    MutexLock lock(&mu_);
-    grpc_pollset_set* interested_parties = watcher->interested_parties();
-    if (interested_parties != nullptr) {
-      grpc_pollset_set_add_pollset_set(pollset_set_, interested_parties);
-    }
-    work_serializer_.Schedule(
-        [watcher = watcher->Ref(), state = state_, status = status_]() mutable {
-          auto* watcher_ptr = watcher.get();
-          watcher_ptr->OnConnectivityStateChange(std::move(watcher), state,
-                                                 status);
-        },
-        DEBUG_LOCATION);
-    watcher_list_.AddWatcherLocked(std::move(watcher));
+  MutexLock lock(&mu_);
+  grpc_pollset_set* interested_parties = watcher->interested_parties();
+  if (interested_parties != nullptr) {
+    grpc_pollset_set_add_pollset_set(pollset_set_, interested_parties);
   }
-  // Drain any connectivity state notifications after releasing the mutex.
-  work_serializer_.DrainQueue();
+  work_serializer_.Run(
+      [watcher = watcher->Ref(), state = state_, status = status_]() mutable {
+        auto* watcher_ptr = watcher.get();
+        watcher_ptr->OnConnectivityStateChange(std::move(watcher), state,
+                                               status);
+      },
+      DEBUG_LOCATION);
+  watcher_list_.AddWatcherLocked(std::move(watcher));
 }
 
 void Subchannel::CancelConnectivityStateWatch(
     ConnectivityStateWatcherInterface* watcher) {
-  {
-    MutexLock lock(&mu_);
-    grpc_pollset_set* interested_parties = watcher->interested_parties();
-    if (interested_parties != nullptr) {
-      grpc_pollset_set_del_pollset_set(pollset_set_, interested_parties);
-    }
-    watcher_list_.RemoveWatcherLocked(watcher);
+  MutexLock lock(&mu_);
+  grpc_pollset_set* interested_parties = watcher->interested_parties();
+  if (interested_parties != nullptr) {
+    grpc_pollset_set_del_pollset_set(pollset_set_, interested_parties);
   }
-  // Drain any connectivity state notifications after releasing the mutex.
-  // (Shouldn't actually be necessary in this case, but better safe than
-  // sorry.)
-  work_serializer_.DrainQueue();
+  watcher_list_.RemoveWatcherLocked(watcher);
 }
 
 void Subchannel::RequestConnection() {
-  {
-    MutexLock lock(&mu_);
-    if (state_ == GRPC_CHANNEL_IDLE) {
-      StartConnectingLocked();
-    }
+  MutexLock lock(&mu_);
+  if (state_ == GRPC_CHANNEL_IDLE) {
+    StartConnectingLocked();
   }
-  // Drain any connectivity state notifications after releasing the mutex.
-  work_serializer_.DrainQueue();
 }
 
 void Subchannel::ResetBackoff() {
@@ -662,18 +644,14 @@ void Subchannel::ResetBackoff() {
   // does not eliminate the last ref and destroy the Subchannel before the
   // method returns.
   auto self = WeakRef(DEBUG_LOCATION, "ResetBackoff");
-  {
-    MutexLock lock(&mu_);
-    backoff_.Reset();
-    if (state_ == GRPC_CHANNEL_TRANSIENT_FAILURE &&
-        event_engine_->Cancel(retry_timer_handle_)) {
-      OnRetryTimerLocked();
-    } else if (state_ == GRPC_CHANNEL_CONNECTING) {
-      next_attempt_time_ = Timestamp::Now();
-    }
+  MutexLock lock(&mu_);
+  backoff_.Reset();
+  if (state_ == GRPC_CHANNEL_TRANSIENT_FAILURE &&
+      event_engine_->Cancel(retry_timer_handle_)) {
+    OnRetryTimerLocked();
+  } else if (state_ == GRPC_CHANNEL_CONNECTING) {
+    next_attempt_time_ = Timestamp::Now();
   }
-  // Drain any connectivity state notifications after releasing the mutex.
-  work_serializer_.DrainQueue();
 }
 
 void Subchannel::Orphaned() {
@@ -683,15 +661,11 @@ void Subchannel::Orphaned() {
     subchannel_pool_->UnregisterSubchannel(key_, this);
     subchannel_pool_.reset();
   }
-  {
-    MutexLock lock(&mu_);
-    CHECK(!shutdown_);
-    shutdown_ = true;
-    connector_.reset();
-    connected_subchannel_.reset();
-  }
-  // Drain any connectivity state notifications after releasing the mutex.
-  work_serializer_.DrainQueue();
+  MutexLock lock(&mu_);
+  CHECK(!shutdown_);
+  shutdown_ = true;
+  connector_.reset();
+  connected_subchannel_.reset();
 }
 
 void Subchannel::GetOrAddDataProducer(
@@ -743,12 +717,8 @@ void Subchannel::SetConnectivityStateLocked(grpc_connectivity_state state,
 }
 
 void Subchannel::OnRetryTimer() {
-  {
-    MutexLock lock(&mu_);
-    OnRetryTimerLocked();
-  }
-  // Drain any connectivity state notifications after releasing the mutex.
-  work_serializer_.DrainQueue();
+  MutexLock lock(&mu_);
+  OnRetryTimerLocked();
 }
 
 void Subchannel::OnRetryTimerLocked() {
@@ -782,8 +752,6 @@ void Subchannel::OnConnectingFinished(void* arg, grpc_error_handle error) {
     MutexLock lock(&c->mu_);
     c->OnConnectingFinishedLocked(error);
   }
-  // Drain any connectivity state notifications after releasing the mutex.
-  c->work_serializer_.DrainQueue();
   c.reset(DEBUG_LOCATION, "Connect");
 }
 
@@ -810,7 +778,6 @@ void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
         time_until_next_attempt,
         [self = WeakRef(DEBUG_LOCATION, "RetryTimer")]() mutable {
           {
-            ApplicationCallbackExecCtx callback_exec_ctx;
             ExecCtx exec_ctx;
             self->OnRetryTimer();
             // Subchannel deletion might require an active ExecCtx. So if

data/src/core/client_channel/subchannel.h

@@ -27,6 +27,7 @@
 #include <memory>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_set.h"
 #include "absl/status/status.h"
 #include "src/core/client_channel/connector.h"
 #include "src/core/client_channel/subchannel_pool_interface.h"
@@ -307,10 +308,9 @@ class Subchannel final : public DualRefCounted<Subchannel> {
 
    private:
     Subchannel* subchannel_;
-    // TODO(roth): Once we can use C++-14 heterogeneous lookups, this can
-    // be a set instead of a map.
-    std::map<ConnectivityStateWatcherInterface*,
-             RefCountedPtr<ConnectivityStateWatcherInterface>>
+    absl::flat_hash_set<RefCountedPtr<ConnectivityStateWatcherInterface>,
+                        RefCountedPtrHash<ConnectivityStateWatcherInterface>,
+                        RefCountedPtrEq<ConnectivityStateWatcherInterface>>
         watchers_;
   };
 

data/src/core/client_channel/subchannel_stream_client.cc

@@ -140,7 +140,6 @@ void SubchannelStreamClient::StartRetryTimerLocked() {
   }
   retry_timer_handle_ = event_engine_->RunAfter(
       timeout, [self = Ref(DEBUG_LOCATION, "health_retry_timer")]() mutable {
-        ApplicationCallbackExecCtx callback_exec_ctx;
         ExecCtx exec_ctx;
         self->OnRetryTimer();
         self.reset(DEBUG_LOCATION, "health_retry_timer");

data/src/core/client_channel/subchannel_stream_client.h

@@ -25,11 +25,11 @@
 
 #include <atomic>
 #include <memory>
+#include <optional>
 
 #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/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -172,7 +172,7 @@ class SubchannelStreamClient final
     grpc_closure recv_initial_metadata_ready_;
 
     // recv_message
-    absl::optional<SliceBuffer> recv_message_;
+    std::optional<SliceBuffer> recv_message_;
     grpc_closure recv_message_ready_;
     std::atomic<bool> seen_response_{false};
 
@@ -208,7 +208,7 @@ class SubchannelStreamClient final
 
   // Call retry state.
   BackOff retry_backoff_ ABSL_GUARDED_BY(mu_);
-  absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+  std::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
       retry_timer_handle_ ABSL_GUARDED_BY(mu_);
   // A raw pointer will suffice since connected_subchannel_ holds a copy of the
   // ChannelArgs which holds an std::shared_ptr of the EventEngine.

data/src/core/config/config_vars.cc

@@ -22,6 +22,7 @@
 
 #include "absl/flags/flag.h"
 #include "absl/strings/escaping.h"
+#include "absl/types/optional.h"
 #include "src/core/config/load_config.h"
 
 #ifndef GPR_DEFAULT_LOG_VERBOSITY_STRING

data/src/core/config/config_vars.h

@@ -23,6 +23,7 @@
 #include <stdint.h>
 
 #include <atomic>
+#include <optional>
 #include <string>
 
 #include "absl/strings/string_view.h"