grpc 1.76.0 → 1.78.0.pre1

data/src/core/client_channel/client_channel_filter.h

@@ -29,13 +29,9 @@
 #include <string>
 #include <utility>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/container/flat_hash_set.h"
-#include "absl/functional/any_invocable.h"
-#include "absl/status/status.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/channelz/channelz.h"
+#include "src/core/client_channel/buffered_call.h"
 #include "src/core/client_channel/client_channel_args.h"
 #include "src/core/client_channel/client_channel_factory.h"
 #include "src/core/client_channel/config_selector.h"
@@ -67,6 +63,12 @@
 #include "src/core/util/time.h"
 #include "src/core/util/time_precise.h"
 #include "src/core/util/work_serializer.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
 
 //
 // Client channel filter
@@ -79,16 +81,6 @@
 // Calls on a disconnected client channel are queued until a connection is
 // established.
 
-// Max number of batches that can be pending on a call at any given
-// time.  This includes one batch for each of the following ops:
-//   recv_initial_metadata
-//   send_initial_metadata
-//   recv_message
-//   send_message
-//   recv_trailing_metadata
-//   send_trailing_metadata
-#define MAX_PENDING_BATCHES 6
-
 namespace grpc_core {
 
 class ClientChannelFilter final {
@@ -96,7 +88,6 @@ class ClientChannelFilter final {
   static const grpc_channel_filter kFilter;
 
   class LoadBalancedCall;
-  class FilterBasedLoadBalancedCall;
 
   // Flag that this object gets stored in channel args as a raw pointer.
   struct RawPointerChannelArgTag {};
@@ -143,14 +134,13 @@ class ClientChannelFilter final {
   void RemoveConnectivityWatcher(
       AsyncConnectivityStateWatcherInterface* watcher);
 
-  OrphanablePtr<FilterBasedLoadBalancedCall> CreateLoadBalancedCall(
+  OrphanablePtr<LoadBalancedCall> CreateLoadBalancedCall(
       const grpc_call_element_args& args, grpc_polling_entity* pollent,
       grpc_closure* on_call_destruction_complete,
       absl::AnyInvocable<void()> on_commit, bool is_transparent_retry);
 
  private:
   class CallData;
-  class FilterBasedCallData;
   class ResolverResultHandler;
   class SubchannelWrapper;
   class ClientChannelControlHelper;
@@ -318,15 +308,12 @@ class ClientChannelFilter final {
       ABSL_GUARDED_BY(*work_serializer_);
   RefCountedPtr<SubchannelPoolInterface> subchannel_pool_
       ABSL_GUARDED_BY(*work_serializer_);
-  // The number of SubchannelWrapper instances referencing a given Subchannel.
-  std::map<Subchannel*, int> subchannel_refcount_map_
-      ABSL_GUARDED_BY(*work_serializer_);
-  // The set of SubchannelWrappers that currently exist.
-  // No need to hold a ref, since the map is updated in the control-plane
+  // The set of SubchannelWrapper instances referencing a given Subchannel.
+  // No need to hold refs, since the map is updated in the control-plane
   // work_serializer when the SubchannelWrappers are created and destroyed.
-  absl::flat_hash_set<SubchannelWrapper*> subchannel_wrappers_
-      ABSL_GUARDED_BY(*work_serializer_);
-  int keepalive_time_ ABSL_GUARDED_BY(*work_serializer_) = -1;
+  absl::flat_hash_map<Subchannel*, absl::flat_hash_set<SubchannelWrapper*>>
+      subchannel_map_ ABSL_GUARDED_BY(*work_serializer_);
+  Duration keepalive_time_ ABSL_GUARDED_BY(*work_serializer_);
   grpc_error_handle disconnect_error_ ABSL_GUARDED_BY(*work_serializer_);
 
   //
@@ -352,15 +339,26 @@ class ClientChannelFilter final {
 
 // TODO(roth): As part of simplifying cancellation in the filter stack,
 // this should no longer need to be ref-counted.
-class ClientChannelFilter::LoadBalancedCall
+class ClientChannelFilter::LoadBalancedCall final
     : public InternallyRefCounted<LoadBalancedCall, UnrefCallDtor> {
  public:
-  LoadBalancedCall(ClientChannelFilter* chand, Arena* arena,
+  // If on_call_destruction_complete is non-null, then it will be
+  // invoked once the LoadBalancedCall is completely destroyed.
+  // If it is null, then the caller is responsible for checking whether
+  // the LB call has a subchannel call and ensuring that the
+  // on_call_destruction_complete closure passed down from the surface
+  // is not invoked until after the subchannel call stack is destroyed.
+  LoadBalancedCall(ClientChannelFilter* chand,
+                   const grpc_call_element_args& args,
+                   grpc_polling_entity* pollent,
+                   grpc_closure* on_call_destruction_complete,
                    absl::AnyInvocable<void()> on_commit,
                    bool is_transparent_retry);
   ~LoadBalancedCall() override;
 
-  void Orphan() override { Unref(); }
+  void Orphan() override;
+
+  void StartTransportStreamOpBatch(grpc_transport_stream_op_batch* batch);
 
   // Called by channel when removing a call from the list of queued calls.
   void RemoveCallFromLbQueuedCallsLocked()
@@ -368,22 +366,22 @@ class ClientChannelFilter::LoadBalancedCall
 
   // Called by the channel for each queued call when a new picker
   // becomes available.
-  virtual void RetryPickLocked()
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ClientChannelFilter::lb_mu_) = 0;
+  void RetryPickLocked()
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ClientChannelFilter::lb_mu_);
 
- protected:
-  ClientChannelFilter* chand() const { return chand_; }
-  CallAttemptTracer* call_attempt_tracer() const {
-    return call_attempt_tracer_;
-  }
-  ConnectedSubchannel* connected_subchannel() const {
-    return connected_subchannel_.get();
+  RefCountedPtr<SubchannelCall> subchannel_call() const {
+    return subchannel_call_;
   }
-  LoadBalancingPolicy::SubchannelCallTrackerInterface*
-  lb_subchannel_call_tracker() const {
-    return lb_subchannel_call_tracker_.get();
+
+ private:
+  class LbCallState;
+  class Metadata;
+  class BackendMetricAccessor;
+  class LbQueuedCallCanceller;
+
+  grpc_metadata_batch* send_initial_metadata() const {
+    return buffered_call_.send_initial_metadata();
   }
-  Arena* arena() const { return arena_; }
 
   void Commit() {
     auto on_commit = std::move(on_commit_);
@@ -409,14 +407,6 @@ class ClientChannelFilter::LoadBalancedCall
 
   void RecordLatency();
 
- private:
-  class LbCallState;
-  class Metadata;
-  class BackendMetricAccessor;
-
-  virtual grpc_polling_entity* pollent() = 0;
-  virtual grpc_metadata_batch* send_initial_metadata() const = 0;
-
   // Helper function for performing an LB pick with a specified picker.
   // Returns true if the pick is complete.
   bool PickSubchannelImpl(LoadBalancingPolicy::SubchannelPicker* picker,
@@ -425,94 +415,6 @@ class ClientChannelFilter::LoadBalancedCall
   void AddCallToLbQueuedCallsLocked()
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ClientChannelFilter::lb_mu_);
 
-  // Called when adding the call to the LB queue.
-  virtual void OnAddToQueueLocked()
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ClientChannelFilter::lb_mu_) = 0;
-
-  ClientChannelFilter* chand_;
-  // When we start a new attempt for a call, we might not have cleaned up the
-  // previous attempt yet leading to a situation where we have two active call
-  // attempt tracers, and so we cannot rely on the arena to give us the right
-  // tracer when performing cleanup.
-  CallAttemptTracer* call_attempt_tracer_;
-
-  absl::AnyInvocable<void()> on_commit_;
-
-  RefCountedPtr<ConnectedSubchannel> connected_subchannel_;
-  const BackendMetricData* backend_metric_data_ = nullptr;
-  std::unique_ptr<LoadBalancingPolicy::SubchannelCallTrackerInterface>
-      lb_subchannel_call_tracker_;
-  Arena* const arena_;
-};
-
-class ClientChannelFilter::FilterBasedLoadBalancedCall final
-    : public ClientChannelFilter::LoadBalancedCall {
- public:
-  // If on_call_destruction_complete is non-null, then it will be
-  // invoked once the LoadBalancedCall is completely destroyed.
-  // If it is null, then the caller is responsible for checking whether
-  // the LB call has a subchannel call and ensuring that the
-  // on_call_destruction_complete closure passed down from the surface
-  // is not invoked until after the subchannel call stack is destroyed.
-  FilterBasedLoadBalancedCall(ClientChannelFilter* chand,
-                              const grpc_call_element_args& args,
-                              grpc_polling_entity* pollent,
-                              grpc_closure* on_call_destruction_complete,
-                              absl::AnyInvocable<void()> on_commit,
-                              bool is_transparent_retry);
-  ~FilterBasedLoadBalancedCall() override;
-
-  void Orphan() override;
-
-  void StartTransportStreamOpBatch(grpc_transport_stream_op_batch* batch);
-
-  RefCountedPtr<SubchannelCall> subchannel_call() const {
-    return subchannel_call_;
-  }
-
- private:
-  class LbQueuedCallCanceller;
-
-  // Work-around for Windows compilers that don't allow nested classes
-  // to access protected members of the enclosing class's parent class.
-  using LoadBalancedCall::chand;
-  using LoadBalancedCall::Commit;
-
-  grpc_polling_entity* pollent() override { return pollent_; }
-  grpc_metadata_batch* send_initial_metadata() const override {
-    return pending_batches_[0]
-        ->payload->send_initial_metadata.send_initial_metadata;
-  }
-
-  // Returns the index into pending_batches_ to be used for batch.
-  static size_t GetBatchIndex(grpc_transport_stream_op_batch* batch);
-  void PendingBatchesAdd(grpc_transport_stream_op_batch* batch);
-  static void FailPendingBatchInCallCombiner(void* arg,
-                                             grpc_error_handle error);
-  // A predicate type and some useful implementations for PendingBatchesFail().
-  typedef bool (*YieldCallCombinerPredicate)(
-      const CallCombinerClosureList& closures);
-  static bool YieldCallCombiner(const CallCombinerClosureList& /*closures*/) {
-    return true;
-  }
-  static bool NoYieldCallCombiner(const CallCombinerClosureList& /*closures*/) {
-    return false;
-  }
-  static bool YieldCallCombinerIfPendingBatchesFound(
-      const CallCombinerClosureList& closures) {
-    return closures.size() > 0;
-  }
-  // Fails all pending batches.
-  // If yield_call_combiner_predicate returns true, assumes responsibility for
-  // yielding the call combiner.
-  void PendingBatchesFail(
-      grpc_error_handle error,
-      YieldCallCombinerPredicate yield_call_combiner_predicate);
-  static void ResumePendingBatchInCallCombiner(void* arg,
-                                               grpc_error_handle ignored);
-  // Resumes all pending batches on subchannel_call_.
-  void PendingBatchesResume();
-
   static void SendInitialMetadataOnComplete(void* arg, grpc_error_handle error);
   static void RecvInitialMetadataReady(void* arg, grpc_error_handle error);
   static void RecvTrailingMetadataReady(void* arg, grpc_error_handle error);
@@ -521,14 +423,15 @@ class ClientChannelFilter::FilterBasedLoadBalancedCall final
   // and when it is queued and the channel gets a new picker.
   void TryPick(bool was_queued);
 
-  void OnAddToQueueLocked() override
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ClientChannelFilter::lb_mu_);
-
-  void RetryPickLocked() override
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ClientChannelFilter::lb_mu_);
-
   void CreateSubchannelCall();
 
+  ClientChannelFilter* chand_;
+  // When we start a new attempt for a call, we might not have cleaned up the
+  // previous attempt yet leading to a situation where we have two active call
+  // attempt tracers, and so we cannot rely on the arena to give us the right
+  // tracer when performing cleanup.
+  CallAttemptTracer* call_attempt_tracer_;
+
   // TODO(roth): Instead of duplicating these fields in every filter
   // that uses any one of them, we should store them in the call
   // context.  This will save per-call memory overhead.
@@ -536,6 +439,15 @@ class ClientChannelFilter::FilterBasedLoadBalancedCall final
   CallCombiner* call_combiner_;
   grpc_polling_entity* pollent_;
   grpc_closure* on_call_destruction_complete_;
+  Arena* const arena_;
+
+  absl::AnyInvocable<void()> on_commit_;
+
+  RefCountedPtr<ConnectedSubchannel> connected_subchannel_;
+  const BackendMetricData* backend_metric_data_ = nullptr;
+  std::unique_ptr<LoadBalancingPolicy::SubchannelCallTrackerInterface>
+      lb_subchannel_call_tracker_;
+
   std::optional<Slice> peer_string_;
 
   // Set when we get a cancel_stream op.
@@ -560,12 +472,7 @@ class ClientChannelFilter::FilterBasedLoadBalancedCall final
   grpc_closure recv_trailing_metadata_ready_;
   grpc_closure* original_recv_trailing_metadata_ready_ = nullptr;
 
-  // Batches are added to this list when received from above.
-  // They are removed when we are done handling the batch (i.e., when
-  // either we have invoked all of the batch's callbacks or we have
-  // passed the batch down to the subchannel call and are not
-  // intercepting any of its callbacks).
-  grpc_transport_stream_op_batch* pending_batches_[MAX_PENDING_BATCHES] = {};
+  BufferedCall buffered_call_;
 };
 
 }  // namespace grpc_core

data/src/core/client_channel/client_channel_internal.h

@@ -21,7 +21,6 @@
 
 #include <utility>
 
-#include "absl/functional/any_invocable.h"
 #include "src/core/call/call_destination.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/load_balancing/lb_policy.h"
@@ -30,6 +29,7 @@
 #include "src/core/util/down_cast.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/unique_type_name.h"
+#include "absl/functional/any_invocable.h"
 
 //
 // This file contains internal interfaces used to allow various plugins
@@ -41,6 +41,10 @@
 #define GRPC_ARG_HEALTH_CHECK_SERVICE_NAME \
   "grpc.internal.health_check_service_name"
 
+// Max number of connections per subchannel.
+#define GRPC_ARG_MAX_CONNECTIONS_PER_SUBCHANNEL \
+  "grpc.internal.max_connections_per_subchannel"
+
 namespace grpc_core {
 
 // Internal type for LB call state interface.  Provides an interface for

data/src/core/client_channel/client_channel_service_config.cc

@@ -22,11 +22,12 @@
 #include <optional>
 #include <utility>
 
+#include "src/core/load_balancing/lb_policy_registry.h"
+#include "src/core/util/env.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/ascii.h"
 #include "absl/strings/str_cat.h"
-#include "src/core/load_balancing/lb_policy_registry.h"
 
 // As per the retry design, we do not allow more than 5 retry attempts.
 #define MAX_MAX_RETRY_ATTEMPTS 5
@@ -34,6 +35,27 @@
 namespace grpc_core {
 namespace internal {
 
+namespace {
+
+bool ConnectionScalingEnabled() {
+  auto value =
+      GetEnv("GRPC_EXPERIMENTAL_MAX_CONCURRENT_STREAMS_CONNECTION_SCALING");
+  if (!value.has_value()) return false;
+  bool parsed_value;
+  bool parse_succeeded = gpr_parse_bool_value(value->c_str(), &parsed_value);
+  return parse_succeeded && parsed_value;
+}
+
+class ConnectionScalingJsonArgs final : public JsonArgs {
+ public:
+  bool IsEnabled(absl::string_view key) const override {
+    if (key == "connection_scaling") return ConnectionScalingEnabled();
+    return true;
+  }
+};
+
+}  // namespace
+
 //
 // ClientChannelGlobalParsedConfig::HealthCheckConfig
 //
@@ -48,6 +70,21 @@ ClientChannelGlobalParsedConfig::HealthCheckConfig::JsonLoader(
   return loader;
 }
 
+//
+// ClientChannelGlobalParsedConfig::ConnectionScaling
+//
+
+const JsonLoaderInterface*
+ClientChannelGlobalParsedConfig::ConnectionScaling::JsonLoader(
+    const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<ConnectionScaling>()
+          .OptionalField("maxConnectionsPerSubchannel",
+                         &ConnectionScaling::max_connections_per_subchannel)
+          .Finish();
+  return loader;
+}
+
 //
 // ClientChannelGlobalParsedConfig
 //
@@ -63,6 +100,9 @@ const JsonLoaderInterface* ClientChannelGlobalParsedConfig::JsonLoader(
               &ClientChannelGlobalParsedConfig::parsed_deprecated_lb_policy_)
           .OptionalField("healthCheckConfig",
                          &ClientChannelGlobalParsedConfig::health_check_config_)
+          .OptionalField("connectionScaling",
+                         &ClientChannelGlobalParsedConfig::connection_scaling_,
+                         "connection_scaling")
           .Finish();
   return loader;
 }
@@ -138,14 +178,14 @@ ClientChannelServiceConfigParser::ParseGlobalParams(const ChannelArgs& /*args*/,
                                                     const Json& json,
                                                     ValidationErrors* errors) {
   return LoadFromJson<std::unique_ptr<ClientChannelGlobalParsedConfig>>(
-      json, JsonArgs(), errors);
+      json, ConnectionScalingJsonArgs(), errors);
 }
 
 std::unique_ptr<ServiceConfigParser::ParsedConfig>
 ClientChannelServiceConfigParser::ParsePerMethodParams(
     const ChannelArgs& /*args*/, const Json& json, ValidationErrors* errors) {
   return LoadFromJson<std::unique_ptr<ClientChannelMethodParsedConfig>>(
-      json, JsonArgs(), errors);
+      json, ConnectionScalingJsonArgs(), errors);
 }
 
 }  // namespace internal

data/src/core/client_channel/client_channel_service_config.h

@@ -24,7 +24,6 @@
 #include <optional>
 #include <string>
 
-#include "absl/strings/string_view.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/load_balancing/lb_policy.h"
@@ -35,6 +34,7 @@
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/time.h"
 #include "src/core/util/validation_errors.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 namespace internal {
@@ -54,6 +54,10 @@ class ClientChannelGlobalParsedConfig final
     return health_check_config_.service_name;
   }
 
+  uint32_t max_connections_per_subchannel() const {
+    return connection_scaling_.max_connections_per_subchannel;
+  }
+
   static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
   void JsonPostLoad(const Json& json, const JsonArgs&,
                     ValidationErrors* errors);
@@ -65,9 +69,16 @@ class ClientChannelGlobalParsedConfig final
     static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
   };
 
+  struct ConnectionScaling {
+    uint32_t max_connections_per_subchannel = 0;
+
+    static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+  };
+
   RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config_;
   std::string parsed_deprecated_lb_policy_;
   HealthCheckConfig health_check_config_;
+  ConnectionScaling connection_scaling_;
 };
 
 class ClientChannelMethodParsedConfig final

data/src/core/client_channel/config_selector.h

@@ -24,8 +24,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/status/status.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/interception_chain.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/client_channel/client_channel_internal.h"
@@ -39,6 +37,8 @@
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/unique_type_name.h"
 #include "src/core/util/useful.h"
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
 
 // Channel arg key for ConfigSelector.
 #define GRPC_ARG_CONFIG_SELECTOR "grpc.internal.config_selector"

data/src/core/client_channel/connector.h

@@ -53,6 +53,8 @@ class SubchannelConnector : public InternallyRefCounted<SubchannelConnector> {
     Transport* transport = nullptr;
     // Channel args to be passed to filters.
     ChannelArgs channel_args;
+    // Initial MAX_CONCURRENT_STREAMS value.
+    uint32_t max_concurrent_streams;
 
     void Reset() {
       if (transport != nullptr) {

data/src/core/client_channel/dynamic_filters.cc

@@ -22,8 +22,6 @@
 #include <new>
 #include <utility>
 
-#include "absl/log/log.h"
-#include "absl/status/statusor.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channel_stack_builder_impl.h"
@@ -33,6 +31,8 @@
 #include "src/core/util/alloc.h"
 #include "src/core/util/grpc_check.h"
 #include "src/core/util/status_helper.h"
+#include "absl/log/log.h"
+#include "absl/status/statusor.h"
 
 // Conversion between call and call stack.
 #define CALL_TO_CALL_STACK(call)                                     \

data/src/core/client_channel/global_subchannel_pool.h

@@ -23,10 +23,10 @@
 
 #include <map>
 
-#include "absl/base/thread_annotations.h"
 #include "src/core/client_channel/subchannel_pool_interface.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
+#include "absl/base/thread_annotations.h"
 
 namespace grpc_core {
 

data/src/core/client_channel/lb_metadata.h

@@ -21,9 +21,9 @@
 #include <string>
 #include <vector>
 
-#include "absl/strings/string_view.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/load_balancing/lb_policy.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

data/src/core/client_channel/load_balanced_call_destination.cc

@@ -14,7 +14,6 @@
 
 #include "src/core/client_channel/load_balanced_call_destination.h"
 
-#include "absl/log/log.h"
 #include "src/core/call/status_util.h"
 #include "src/core/client_channel/client_channel.h"
 #include "src/core/client_channel/client_channel_internal.h"
@@ -23,6 +22,7 @@
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/promise/loop.h"
 #include "src/core/telemetry/call_tracer.h"
+#include "absl/log/log.h"
 
 namespace grpc_core {
 
@@ -135,11 +135,9 @@ LoopCtl<absl::StatusOr<RefCountedPtr<UnstartedCallDestination>>> PickSubchannel(
                  "pick";
           return Continue{};
         }
-        // If the LB policy returned a call tracker, inform it that the
-        // call is starting and add it to context, so that we can notify
-        // it when the call finishes.
+        // If the LB policy returned a call tracker, add it to context, so
+        // that we can notify it when the call finishes.
         if (complete_pick->subchannel_call_tracker != nullptr) {
-          complete_pick->subchannel_call_tracker->Start();
           SetContext(complete_pick->subchannel_call_tracker.release());
         }
         // Apply metadata mutations, if any.

data/src/core/client_channel/load_balanced_call_destination.h

@@ -15,11 +15,11 @@
 #ifndef GRPC_SRC_CORE_CLIENT_CHANNEL_LOAD_BALANCED_CALL_DESTINATION_H
 #define GRPC_SRC_CORE_CLIENT_CHANNEL_LOAD_BALANCED_CALL_DESTINATION_H
 
-#include "absl/functional/any_invocable.h"
 #include "src/core/call/call_destination.h"
 #include "src/core/client_channel/client_channel.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/load_balancing/lb_policy.h"
+#include "absl/functional/any_invocable.h"
 
 namespace grpc_core {
 

data/src/core/client_channel/retry_filter.cc

@@ -22,8 +22,6 @@
 #include <optional>
 #include <string>
 
-#include "absl/status/statusor.h"
-#include "absl/strings/strip.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"
@@ -35,6 +33,8 @@
 #include "src/core/service_config/service_config_call_data.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/uri.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/strip.h"
 
 //
 // Retry filter

data/src/core/client_channel/retry_filter_legacy_call_data.cc

@@ -20,9 +20,6 @@
 #include <memory>
 #include <new>
 
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/call/status_util.h"
 #include "src/core/client_channel/client_channel_internal.h"
@@ -50,6 +47,9 @@
 #include "src/core/util/status_helper.h"
 #include "src/core/util/time.h"
 #include "src/core/util/useful.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
 
 namespace grpc_core {
 
@@ -293,9 +293,8 @@ namespace {
 void StartBatchInCallCombiner(void* arg, grpc_error_handle /*ignored*/) {
   grpc_transport_stream_op_batch* batch =
       static_cast<grpc_transport_stream_op_batch*>(arg);
-  auto* lb_call =
-      static_cast<ClientChannelFilter::FilterBasedLoadBalancedCall*>(
-          batch->handler_private.extra_arg);
+  auto* lb_call = static_cast<ClientChannelFilter::LoadBalancedCall*>(
+      batch->handler_private.extra_arg);
   // Note: This will release the call combiner.
   lb_call->StartTransportStreamOpBatch(batch);
 }
@@ -1626,7 +1625,7 @@ void RetryFilter::LegacyCallData::StartTransportStreamOpBatch(
   call_attempt_->StartRetriableBatches();
 }
 
-OrphanablePtr<ClientChannelFilter::FilterBasedLoadBalancedCall>
+OrphanablePtr<ClientChannelFilter::LoadBalancedCall>
 RetryFilter::LegacyCallData::CreateLoadBalancedCall(
     absl::AnyInvocable<void()> on_commit, bool is_transparent_retry) {
   grpc_call_element_args args = {owning_call_,     nullptr,