grpc 1.70.1 → 1.71.0

data/src/core/lib/transport/timeout_encoding.cc

@@ -109,19 +109,19 @@ Slice Timeout::Encode() const {
     case 5:
       *p++ = '0' + n / 10000;
       n %= 10000;
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case 4:
       *p++ = '0' + n / 1000;
       n %= 1000;
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case 3:
       *p++ = '0' + n / 100;
       n %= 100;
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case 2:
       *p++ = '0' + n / 10;
       n %= 10;
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case 1:
       *p++ = '0' + n;
   }
@@ -131,28 +131,28 @@ Slice Timeout::Encode() const {
       break;
     case Unit::kHundredMilliseconds:
       *p++ = '0';
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case Unit::kTenMilliseconds:
       *p++ = '0';
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case Unit::kMilliseconds:
       *p++ = 'm';
       break;
     case Unit::kHundredSeconds:
       *p++ = '0';
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case Unit::kTenSeconds:
       *p++ = '0';
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case Unit::kSeconds:
       *p++ = 'S';
       break;
     case Unit::kHundredMinutes:
       *p++ = '0';
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case Unit::kTenMinutes:
       *p++ = '0';
-      ABSL_FALLTHROUGH_INTENDED;
+      [[fallthrough]];
     case Unit::kMinutes:
       *p++ = 'M';
       break;
@@ -229,7 +229,7 @@ Timeout Timeout::FromHours(int64_t hours) {
   return Timeout(kMaxHours, Unit::kHours);
 }
 
-absl::optional<Duration> ParseTimeout(const Slice& text) {
+std::optional<Duration> ParseTimeout(const Slice& text) {
   int32_t x = 0;
   const uint8_t* p = text.begin();
   const uint8_t* end = text.end();
@@ -249,11 +249,11 @@ absl::optional<Duration> ParseTimeout(const Slice& text) {
     }
     x = x * 10 + digit;
   }
-  if (!have_digit) return absl::nullopt;
+  if (!have_digit) return std::nullopt;
   // skip whitespace
   for (; p != end && *p == ' '; p++) {
   }
-  if (p == end) return absl::nullopt;
+  if (p == end) return std::nullopt;
   // decode unit specifier
   Duration timeout;
   switch (*p) {
@@ -278,10 +278,10 @@ absl::optional<Duration> ParseTimeout(const Slice& text) {
       timeout = Duration::Hours(x);
       break;
     default:
-      return absl::nullopt;
+      return std::nullopt;
   }
   p++;
-  if (!IsAllSpace(p, end)) return absl::nullopt;
+  if (!IsAllSpace(p, end)) return std::nullopt;
   return timeout;
 }
 

data/src/core/lib/transport/timeout_encoding.h

@@ -22,7 +22,8 @@
 #include <grpc/support/port_platform.h>
 #include <stdint.h>
 
-#include "absl/types/optional.h"
+#include <optional>
+
 #include "src/core/lib/slice/slice.h"
 #include "src/core/util/time.h"
 
@@ -63,7 +64,7 @@ class Timeout {
   Unit unit_ = Unit::kNanoseconds;
 };
 
-absl::optional<Duration> ParseTimeout(const Slice& text);
+std::optional<Duration> ParseTimeout(const Slice& text);
 
 }  // namespace grpc_core
 

data/src/core/lib/transport/transport.cc

@@ -49,7 +49,6 @@ void grpc_stream_destroy(grpc_stream_refcount* refcount) {
     // Throw this over to the executor (on a core-owned thread) and process it
     // there.
     grpc_event_engine::experimental::GetDefaultEventEngine()->Run([refcount] {
-      grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
       grpc_core::ExecCtx exec_ctx;
       grpc_core::ExecCtx::Run(DEBUG_LOCATION, &refcount->destroy,
                               absl::OkStatus());

data/src/core/lib/transport/transport.h

@@ -29,6 +29,7 @@
 #include <string.h>
 
 #include <functional>
+#include <optional>
 #include <string>
 #include <utility>
 
@@ -36,7 +37,6 @@
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -69,6 +69,13 @@
 
 #define GRPC_ARG_TRANSPORT "grpc.internal.transport"
 
+/** A comma separated list of supported transport protocols. If non-empty,
+ allows the client and server to attempt to negotiate transport protocols.
+ NOTE: This is an experimental feature. It is not fully implemented and is not
+ currently functional.
+ TODO(gtcooke94) - update with specific details when implementing. */
+#define GRPC_ARG_TRANSPORT_PROTOCOLS "grpc.internal.transport_protocols"
+
 namespace grpc_core {
 
 // Move only type that tracks call startup.
@@ -364,7 +371,7 @@ struct grpc_transport_stream_op_batch_payload {
     // Will be set by the transport to point to the byte stream containing a
     // received message. Will be nullopt if trailing metadata is received
     // instead of a message.
-    absl::optional<grpc_core::SliceBuffer>* recv_message = nullptr;
+    std::optional<grpc_core::SliceBuffer>* recv_message = nullptr;
     uint32_t* flags = nullptr;
     // Was this recv_message failed for reasons other than a clean end-of-stream
     bool* call_failed_before_recv_message = nullptr;
@@ -413,12 +420,10 @@ typedef struct grpc_transport_op {
   grpc_core::ConnectivityStateWatcherInterface* stop_connectivity_watch =
       nullptr;
   /// should the transport be disconnected
-  /// Error contract: the transport that gets this op must cause
-  ///                disconnect_with_error to be unref'ed after processing it
   grpc_error_handle disconnect_with_error;
-  /// what should the goaway contain?
-  /// Error contract: the transport that gets this op must cause
-  ///                goaway_error to be unref'ed after processing it
+  /// Start a graceful goaway with the specified error message. (The error code
+  /// is ignored since graceful GOAWAYs use a NO_ERROR error code.) Use
+  /// disconnect_with_error if graceful shutdown is not needed.
   grpc_error_handle goaway_error;
   void (*set_accept_stream_fn)(void* user_data, grpc_core::Transport* transport,
                                const void* server_data) = nullptr;

data/src/core/load_balancing/backend_metric_parser.cc

@@ -31,23 +31,23 @@ namespace grpc_core {
 
 namespace {
 
-template <typename EntryType>
+// TODO(b/397931390): Clean up the code after gRPC OSS migrates to proto v30.0.
 std::map<absl::string_view, double> ParseMap(
     xds_data_orca_v3_OrcaLoadReport* msg,
-    const EntryType* (*entry_func)(const xds_data_orca_v3_OrcaLoadReport*,
-                                   size_t*),
-    upb_StringView (*key_func)(const EntryType*),
-    double (*value_func)(const EntryType*),
+    const upb_Map* (*upb_map_func)(xds_data_orca_v3_OrcaLoadReport*),
     BackendMetricAllocatorInterface* allocator) {
+  const upb_Map* map = upb_map_func(msg);
   std::map<absl::string_view, double> result;
-  size_t i = kUpb_Map_Begin;
-  while (true) {
-    const auto* entry = entry_func(msg, &i);
-    if (entry == nullptr) break;
-    upb_StringView key_view = key_func(entry);
-    char* key = allocator->AllocateString(key_view.size);
-    memcpy(key, key_view.data, key_view.size);
-    result[absl::string_view(key, key_view.size)] = value_func(entry);
+  if (map) {
+    size_t i = kUpb_Map_Begin;
+    upb_MessageValue k, v;
+    while (upb_Map_Next(map, &k, &v, &i)) {
+      upb_StringView key_view = k.str_val;
+      double value = v.double_val;
+      char* key = allocator->AllocateString(key_view.size);
+      memcpy(key, key_view.data, key_view.size);
+      result[absl::string_view(key, key_view.size)] = value;
+    }
   }
   return result;
 }
@@ -73,21 +73,14 @@ const BackendMetricData* ParseBackendMetricData(
   backend_metric_data->qps =
       xds_data_orca_v3_OrcaLoadReport_rps_fractional(msg);
   backend_metric_data->eps = xds_data_orca_v3_OrcaLoadReport_eps(msg);
-  backend_metric_data->request_cost =
-      ParseMap<xds_data_orca_v3_OrcaLoadReport_RequestCostEntry>(
-          msg, xds_data_orca_v3_OrcaLoadReport_request_cost_next,
-          xds_data_orca_v3_OrcaLoadReport_RequestCostEntry_key,
-          xds_data_orca_v3_OrcaLoadReport_RequestCostEntry_value, allocator);
-  backend_metric_data->utilization =
-      ParseMap<xds_data_orca_v3_OrcaLoadReport_UtilizationEntry>(
-          msg, xds_data_orca_v3_OrcaLoadReport_utilization_next,
-          xds_data_orca_v3_OrcaLoadReport_UtilizationEntry_key,
-          xds_data_orca_v3_OrcaLoadReport_UtilizationEntry_value, allocator);
-  backend_metric_data->named_metrics =
-      ParseMap<xds_data_orca_v3_OrcaLoadReport_NamedMetricsEntry>(
-          msg, xds_data_orca_v3_OrcaLoadReport_named_metrics_next,
-          xds_data_orca_v3_OrcaLoadReport_NamedMetricsEntry_key,
-          xds_data_orca_v3_OrcaLoadReport_NamedMetricsEntry_value, allocator);
+  // TODO(b/397931390): Clean up the code after gRPC OSS migrates to proto
+  // v30.0.
+  backend_metric_data->request_cost = ParseMap(
+      msg, _xds_data_orca_v3_OrcaLoadReport_request_cost_upb_map, allocator);
+  backend_metric_data->utilization = ParseMap(
+      msg, _xds_data_orca_v3_OrcaLoadReport_utilization_upb_map, allocator);
+  backend_metric_data->named_metrics = ParseMap(
+      msg, _xds_data_orca_v3_OrcaLoadReport_named_metrics_upb_map, allocator);
   return backend_metric_data;
 }
 

data/src/core/load_balancing/endpoint_list.cc

@@ -22,6 +22,7 @@
 #include <stdlib.h>
 
 #include <memory>
+#include <optional>
 #include <utility>
 #include <vector>
 
@@ -29,7 +30,6 @@
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.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/iomgr/pollset_set.h"

data/src/core/load_balancing/endpoint_list.h

@@ -22,12 +22,12 @@
 #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"
@@ -84,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...
@@ -111,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 {
@@ -151,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(
@@ -163,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_;
   };
 

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);
+                });
           });
 }