grpc 1.72.0 → 1.78.1

data/src/core/client_channel/client_channel_filter.cc

@@ -37,16 +37,6 @@
 #include <variant>
 #include <vector>
 
-#include "absl/cleanup/cleanup.h"
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/status/statusor.h"
-#include "absl/strings/cord.h"
-#include "absl/strings/numbers.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_join.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/call/status_util.h"
 #include "src/core/channelz/channel_trace.h"
@@ -96,6 +86,7 @@
 #include "src/core/service_config/service_config_impl.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/manual_constructor.h"
 #include "src/core/util/status_helper.h"
@@ -103,6 +94,15 @@
 #include "src/core/util/unique_type_name.h"
 #include "src/core/util/useful.h"
 #include "src/core/util/work_serializer.h"
+#include "absl/cleanup/cleanup.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/string_view.h"
 
 //
 // Client channel filter
@@ -118,6 +118,15 @@ using internal::ClientChannelMethodParsedConfig;
 
 class ClientChannelFilter::CallData {
  public:
+  static grpc_error_handle Init(grpc_call_element* elem,
+                                const grpc_call_element_args* args);
+  static void Destroy(grpc_call_element* elem,
+                      const grpc_call_final_info* final_info,
+                      grpc_closure* then_schedule_closure);
+  static void StartTransportStreamOpBatch(
+      grpc_call_element* elem, grpc_transport_stream_op_batch* batch);
+  static void SetPollent(grpc_call_element* elem, grpc_polling_entity* pollent);
+
   // Removes the call from the channel's list of calls queued
   // for name resolution.
   void RemoveCallFromResolverQueuedCallsLocked()
@@ -125,16 +134,21 @@ class ClientChannelFilter::CallData {
 
   // Called by the channel for each queued call when a new resolution
   // result becomes available.
-  virtual void RetryCheckResolutionLocked()
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ClientChannelFilter::resolution_mu_) = 0;
+  void RetryCheckResolutionLocked()
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ClientChannelFilter::resolution_mu_);
+
+ private:
+  class ResolverQueuedCallCanceller;
 
-  RefCountedPtr<DynamicFilters> dynamic_filters() const {
-    return dynamic_filters_;
+  CallData(grpc_call_element* elem, const grpc_call_element_args& args);
+
+  ClientChannelFilter* chand() const {
+    return static_cast<ClientChannelFilter*>(elem_->channel_data);
   }
 
- protected:
-  CallData() = default;
-  virtual ~CallData() = default;
+  grpc_metadata_batch* send_initial_metadata() {
+    return buffered_call_.send_initial_metadata();
+  }
 
   // Checks whether a resolver result is available.  The following
   // outcomes are possible:
@@ -148,13 +162,6 @@ class ClientChannelFilter::CallData {
   //   stored in the call context and an OK status will be returned.
   std::optional<absl::Status> CheckResolution(bool was_queued);
 
- private:
-  // Accessors for data stored in the subclass.
-  virtual ClientChannelFilter* chand() const = 0;
-  virtual Arena* arena() const = 0;
-  virtual grpc_polling_entity* pollent() = 0;
-  virtual grpc_metadata_batch* send_initial_metadata() = 0;
-
   // Helper function for CheckResolution().  Returns true if the call
   // can continue (i.e., there is a valid resolution result, or there is
   // an invalid resolution result but the call is not wait_for_ready).
@@ -166,10 +173,6 @@ class ClientChannelFilter::CallData {
   void AddCallToResolverQueuedCallsLocked()
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ClientChannelFilter::resolution_mu_);
 
-  // Called when adding the call to the resolver queue.
-  virtual void OnAddToQueueLocked()
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ClientChannelFilter::resolution_mu_) {}
-
   // Applies service config to the call.  Must be invoked once we know
   // that the resolver has returned results to the channel.
   // If an error is returned, the error indicates the status with which
@@ -179,90 +182,19 @@ class ClientChannelFilter::CallData {
 
   // Called to reset the deadline based on the service config obtained
   // from the resolver.
-  virtual void ResetDeadline(Duration timeout) = 0;
-
-  RefCountedPtr<DynamicFilters> dynamic_filters_;
-};
-
-class ClientChannelFilter::FilterBasedCallData final
-    : public ClientChannelFilter::CallData {
- public:
-  static grpc_error_handle Init(grpc_call_element* elem,
-                                const grpc_call_element_args* args);
-  static void Destroy(grpc_call_element* elem,
-                      const grpc_call_final_info* final_info,
-                      grpc_closure* then_schedule_closure);
-  static void StartTransportStreamOpBatch(
-      grpc_call_element* elem, grpc_transport_stream_op_batch* batch);
-  static void SetPollent(grpc_call_element* elem, grpc_polling_entity* pollent);
-
- private:
-  class ResolverQueuedCallCanceller;
-
-  FilterBasedCallData(grpc_call_element* elem,
-                      const grpc_call_element_args& args);
-  ~FilterBasedCallData() override;
-
-  grpc_call_element* elem() const { return elem_; }
-  grpc_call_stack* owning_call() const { return owning_call_; }
-  CallCombiner* call_combiner() const { return call_combiner_; }
-
-  ClientChannelFilter* chand() const override {
-    return static_cast<ClientChannelFilter*>(elem()->channel_data);
-  }
-  Arena* arena() const override { return arena_; }
-  grpc_polling_entity* pollent() override { return pollent_; }
-  grpc_metadata_batch* send_initial_metadata() 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;
+  void ResetDeadline(Duration timeout) {
+    const Timestamp per_method_deadline =
+        Timestamp::FromCycleCounterRoundUp(call_start_time_) + timeout;
+    arena_->GetContext<Call>()
+        ->UpdateDeadline(per_method_deadline)
+        .IgnoreError();
   }
-  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 dynamic_call_.
-  void PendingBatchesResume();
 
   // Called to check for a resolution result, both when the call is
   // initially started and when it is queued and the channel gets a new
   // resolution result.
   void TryCheckResolution(bool was_queued);
 
-  void OnAddToQueueLocked() override
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ClientChannelFilter::resolution_mu_);
-
-  void RetryCheckResolutionLocked() override
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ClientChannelFilter::resolution_mu_);
-
-  void ResetDeadline(Duration timeout) override {
-    const Timestamp per_method_deadline =
-        Timestamp::FromCycleCounterRoundUp(call_start_time_) + timeout;
-    arena_->GetContext<Call>()->UpdateDeadline(per_method_deadline);
-  }
-
   void CreateDynamicCall();
 
   static void RecvTrailingMetadataReadyForConfigSelectorCommitCallback(
@@ -285,14 +217,10 @@ class ClientChannelFilter::FilterBasedCallData final
   grpc_closure* original_recv_trailing_metadata_ready_ = nullptr;
   grpc_closure recv_trailing_metadata_ready_;
 
+  RefCountedPtr<DynamicFilters> dynamic_filters_;
   RefCountedPtr<DynamicFilters::Call> dynamic_call_;
 
-  // 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 LB call and are not intercepting any of
-  // its callbacks).
-  grpc_transport_stream_op_batch* pending_batches_[MAX_PENDING_BATCHES] = {};
+  BufferedCall buffered_call_;
 
   // Set when we get a cancel_stream op.
   grpc_error_handle cancel_error_;
@@ -303,12 +231,12 @@ class ClientChannelFilter::FilterBasedCallData final
 //
 
 const grpc_channel_filter ClientChannelFilter::kFilter = {
-    ClientChannelFilter::FilterBasedCallData::StartTransportStreamOpBatch,
+    ClientChannelFilter::CallData::StartTransportStreamOpBatch,
     ClientChannelFilter::StartTransportOp,
-    sizeof(ClientChannelFilter::FilterBasedCallData),
-    ClientChannelFilter::FilterBasedCallData::Init,
-    ClientChannelFilter::FilterBasedCallData::SetPollent,
-    ClientChannelFilter::FilterBasedCallData::Destroy,
+    sizeof(ClientChannelFilter::CallData),
+    ClientChannelFilter::CallData::Init,
+    ClientChannelFilter::CallData::SetPollent,
+    ClientChannelFilter::CallData::Destroy,
     sizeof(ClientChannelFilter),
     ClientChannelFilter::Init,
     grpc_channel_stack_no_post_init,
@@ -336,8 +264,8 @@ class DynamicTerminationFilter final {
 
   static grpc_error_handle Init(grpc_channel_element* elem,
                                 grpc_channel_element_args* args) {
-    CHECK(args->is_last);
-    CHECK(elem->filter == &kFilterVtable);
+    GRPC_CHECK(args->is_last);
+    GRPC_CHECK(elem->filter == &kFilterVtable);
     new (elem->channel_data) DynamicTerminationFilter(args->channel_args);
     return absl::OkStatus();
   }
@@ -421,7 +349,7 @@ class DynamicTerminationFilter::CallData final {
   grpc_call_stack* owning_call_;
   CallCombiner* call_combiner_;
 
-  OrphanablePtr<ClientChannelFilter::FilterBasedLoadBalancedCall> lb_call_;
+  OrphanablePtr<ClientChannelFilter::LoadBalancedCall> lb_call_;
 };
 
 const grpc_channel_filter DynamicTerminationFilter::kFilterVtable = {
@@ -483,32 +411,31 @@ class ClientChannelFilter::SubchannelWrapper final
     : public SubchannelInterface {
  public:
   SubchannelWrapper(ClientChannelFilter* chand,
-                    RefCountedPtr<Subchannel> subchannel)
+                    RefCountedPtr<Subchannel> subchannel,
+                    uint32_t max_connections_per_subchannel)
       : SubchannelInterface(GRPC_TRACE_FLAG_ENABLED(client_channel)
                                 ? "SubchannelWrapper"
                                 : nullptr),
         chand_(chand),
-        subchannel_(std::move(subchannel)) {
+        subchannel_(std::move(subchannel)),
+        max_connections_per_subchannel_(max_connections_per_subchannel) {
     GRPC_TRACE_LOG(client_channel, INFO)
         << "chand=" << chand << ": creating subchannel wrapper " << this
-        << " for subchannel " << subchannel_.get();
+        << " for subchannel " << subchannel_.get()
+        << ", max_connections_per_subchannel="
+        << max_connections_per_subchannel;
     GRPC_CHANNEL_STACK_REF(chand_->owning_stack_, "SubchannelWrapper");
 #ifndef NDEBUG
-    DCHECK(chand_->work_serializer_->RunningInWorkSerializer());
+    GRPC_DCHECK(chand_->work_serializer_->RunningInWorkSerializer());
 #endif
-    if (chand_->channelz_node_ != nullptr) {
+    auto& subchannel_wrappers = chand_->subchannel_map_[subchannel_.get()];
+    if (subchannel_wrappers.empty() && chand_->channelz_node_ != nullptr) {
       auto* subchannel_node = subchannel_->channelz_node();
       if (subchannel_node != nullptr) {
-        auto it = chand_->subchannel_refcount_map_.find(subchannel_.get());
-        if (it == chand_->subchannel_refcount_map_.end()) {
-          chand_->channelz_node_->AddChildSubchannel(subchannel_node->uuid());
-          it = chand_->subchannel_refcount_map_.emplace(subchannel_.get(), 0)
-                   .first;
-        }
-        ++it->second;
+        subchannel_node->AddParent(chand_->channelz_node_);
       }
     }
-    chand_->subchannel_wrappers_.insert(this);
+    subchannel_wrappers.insert(this);
   }
 
   ~SubchannelWrapper() override {
@@ -523,34 +450,47 @@ class ClientChannelFilter::SubchannelWrapper final
     // WorkSerializer.
     // Ref held by callback.
     WeakRef(DEBUG_LOCATION, "subchannel map cleanup").release();
-    chand_->work_serializer_->Run([this]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(
-                                      *chand_->work_serializer_) {
-      chand_->subchannel_wrappers_.erase(this);
-      if (chand_->channelz_node_ != nullptr) {
-        auto* subchannel_node = subchannel_->channelz_node();
-        if (subchannel_node != nullptr) {
-          auto it = chand_->subchannel_refcount_map_.find(subchannel_.get());
-          CHECK(it != chand_->subchannel_refcount_map_.end());
-          --it->second;
-          if (it->second == 0) {
-            chand_->channelz_node_->RemoveChildSubchannel(
-                subchannel_node->uuid());
-            chand_->subchannel_refcount_map_.erase(it);
+    chand_->work_serializer_->Run(
+        [this]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
+          auto it = chand_->subchannel_map_.find(subchannel_.get());
+          GRPC_CHECK(it != chand_->subchannel_map_.end());
+          auto& subchannel_wrappers = it->second;
+          subchannel_wrappers.erase(this);
+          if (subchannel_wrappers.empty()) {
+            if (chand_->channelz_node_ != nullptr) {
+              auto* subchannel_node = subchannel_->channelz_node();
+              if (subchannel_node != nullptr) {
+                subchannel_node->RemoveParent(chand_->channelz_node_);
+              }
+            }
+            chand_->subchannel_map_.erase(it);
           }
-        }
-      }
-      WeakUnref(DEBUG_LOCATION, "subchannel map cleanup");
-    });
+          if (IsSubchannelWrapperCleanupOnOrphanEnabled()) {
+            // We need to make sure that the internal subchannel gets unreffed
+            // inside of the WorkSerializer, so that updates to the local
+            // subchannel pool are properly synchronized.  To that end, we
+            // drop our ref to the internal subchannel here.  We also cancel
+            // any watchers that were not properly cancelled, in case any of
+            // them are holding a ref to the internal subchannel.
+            for (const auto& [_, watcher] : watcher_map_) {
+              subchannel_->CancelConnectivityStateWatch(watcher);
+            }
+            watcher_map_.clear();
+            data_watchers_.clear();
+            subchannel_.reset();
+          }
+          WeakUnref(DEBUG_LOCATION, "subchannel map cleanup");
+        });
   }
 
   void WatchConnectivityState(
       std::unique_ptr<ConnectivityStateWatcherInterface> watcher) override
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     auto& watcher_wrapper = watcher_map_[watcher.get()];
-    CHECK_EQ(watcher_wrapper, nullptr);
+    GRPC_CHECK_EQ(watcher_wrapper, nullptr);
     watcher_wrapper = new WatcherWrapper(
         std::move(watcher),
-        RefAsSubclass<SubchannelWrapper>(DEBUG_LOCATION, "WatcherWrapper"));
+        WeakRefAsSubclass<SubchannelWrapper>(DEBUG_LOCATION, "WatcherWrapper"));
     subchannel_->WatchConnectivityState(
         RefCountedPtr<Subchannel::ConnectivityStateWatcherInterface>(
             watcher_wrapper));
@@ -559,7 +499,7 @@ class ClientChannelFilter::SubchannelWrapper final
   void CancelConnectivityStateWatch(ConnectivityStateWatcherInterface* watcher)
       override ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     auto it = watcher_map_.find(watcher);
-    CHECK(it != watcher_map_.end());
+    GRPC_CHECK(it != watcher_map_.end());
     subchannel_->CancelConnectivityStateWatch(it->second);
     watcher_map_.erase(it);
   }
@@ -576,7 +516,7 @@ class ClientChannelFilter::SubchannelWrapper final
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     static_cast<InternalSubchannelDataWatcherInterface*>(watcher.get())
         ->SetSubchannel(subchannel_.get());
-    CHECK(data_watchers_.insert(std::move(watcher)).second);
+    GRPC_CHECK(data_watchers_.insert(std::move(watcher)).second);
   }
 
   void CancelDataWatcher(DataWatcherInterface* watcher) override
@@ -585,10 +525,6 @@ class ClientChannelFilter::SubchannelWrapper final
     if (it != data_watchers_.end()) data_watchers_.erase(it);
   }
 
-  void ThrottleKeepaliveTime(int new_keepalive_time) {
-    subchannel_->ThrottleKeepaliveTime(new_keepalive_time);
-  }
-
   std::string address() const override { return subchannel_->address(); }
 
  private:
@@ -610,30 +546,44 @@ class ClientChannelFilter::SubchannelWrapper final
     WatcherWrapper(
         std::unique_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
             watcher,
-        RefCountedPtr<SubchannelWrapper> parent)
+        WeakRefCountedPtr<SubchannelWrapper> parent)
         : watcher_(std::move(watcher)), parent_(std::move(parent)) {}
 
     ~WatcherWrapper() override {
       parent_.reset(DEBUG_LOCATION, "WatcherWrapper");
     }
 
-    void OnConnectivityStateChange(
-        RefCountedPtr<ConnectivityStateWatcherInterface> self,
-        grpc_connectivity_state state, const absl::Status& status) override {
+    void OnConnectivityStateChange(grpc_connectivity_state state,
+                                   const absl::Status& status) override {
       GRPC_TRACE_LOG(client_channel, INFO)
           << "chand=" << parent_->chand_
           << ": connectivity change for subchannel wrapper " << parent_.get()
-          << " subchannel " << parent_->subchannel_.get()
           << "hopping into work_serializer";
-      self.release();  // Held by callback.
+      auto self = RefAsSubclass<WatcherWrapper>();
+      parent_->chand_->work_serializer_->Run(
+          [self, state, status]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(
+              *self->parent_->chand_->work_serializer_) {
+            self->ApplyUpdateInControlPlaneWorkSerializer(state, status);
+          });
+    }
+
+    void OnKeepaliveUpdate(Duration new_keepalive_time) override {
+      GRPC_TRACE_LOG(client_channel, INFO)
+          << "chand=" << parent_->chand_
+          << ": keepalive update for subchannel wrapper " << parent_.get()
+          << "hopping into work_serializer";
+      auto self = RefAsSubclass<WatcherWrapper>();
       parent_->chand_->work_serializer_->Run(
-          [this, state, status]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(
-              *parent_->chand_->work_serializer_) {
-            ApplyUpdateInControlPlaneWorkSerializer(state, status);
-            Unref();
+          [self, new_keepalive_time]() ABSL_EXCLUSIVE_LOCKS_REQUIRED(
+              *self->parent_->chand_->work_serializer_) {
+            self->ApplyKeepaliveThrottlingInWorkSerializer(new_keepalive_time);
           });
     }
 
+    uint32_t max_connections_per_subchannel() const override {
+      return parent_->max_connections_per_subchannel_;
+    }
+
     grpc_pollset_set* interested_parties() override {
       return watcher_->interested_parties();
     }
@@ -649,29 +599,33 @@ class ClientChannelFilter::SubchannelWrapper final
           << parent_.get() << " subchannel " << parent_->subchannel_.get()
           << " watcher=" << watcher_.get()
           << " state=" << ConnectivityStateName(state) << " status=" << status;
-      auto keepalive_throttling = status.GetPayload(kKeepaliveThrottlingKey);
-      if (keepalive_throttling.has_value()) {
-        int new_keepalive_time = -1;
-        if (absl::SimpleAtoi(std::string(keepalive_throttling.value()),
-                             &new_keepalive_time)) {
-          if (new_keepalive_time > parent_->chand_->keepalive_time_) {
-            parent_->chand_->keepalive_time_ = new_keepalive_time;
-            GRPC_TRACE_LOG(client_channel, INFO)
-                << "chand=" << parent_->chand_
-                << ": throttling keepalive time to "
-                << parent_->chand_->keepalive_time_;
-            // Propagate the new keepalive time to all subchannels. This is so
-            // that new transports created by any subchannel (and not just the
-            // subchannel that received the GOAWAY), use the new keepalive time.
-            for (auto* subchannel_wrapper :
-                 parent_->chand_->subchannel_wrappers_) {
-              subchannel_wrapper->ThrottleKeepaliveTime(new_keepalive_time);
+      if (!IsTransportStateWatcherEnabled()) {
+        auto keepalive_throttling = status.GetPayload(kKeepaliveThrottlingKey);
+        if (keepalive_throttling.has_value()) {
+          int new_keepalive_time_ms = -1;
+          if (absl::SimpleAtoi(std::string(keepalive_throttling.value()),
+                               &new_keepalive_time_ms)) {
+            Duration new_keepalive_time =
+                Duration::Milliseconds(new_keepalive_time_ms);
+            if (new_keepalive_time > parent_->chand_->keepalive_time_) {
+              parent_->chand_->keepalive_time_ = new_keepalive_time;
+              GRPC_TRACE_LOG(client_channel, INFO)
+                  << "chand=" << parent_->chand_
+                  << ": throttling keepalive time to "
+                  << parent_->chand_->keepalive_time_;
+              // Propagate the new keepalive time to all subchannels. This is
+              // so that new transports created by any subchannel (and not
+              // just the subchannel that received the GOAWAY), use the new
+              // keepalive time.
+              for (auto& [subchannel, _] : parent_->chand_->subchannel_map_) {
+                subchannel->ThrottleKeepaliveTime(new_keepalive_time);
+              }
             }
+          } else {
+            LOG(ERROR) << "chand=" << parent_->chand_
+                       << ": Illegal keepalive throttling value "
+                       << std::string(keepalive_throttling.value());
           }
-        } else {
-          LOG(ERROR) << "chand=" << parent_->chand_
-                     << ": Illegal keepalive throttling value "
-                     << std::string(keepalive_throttling.value());
         }
       }
       // Propagate status only in state TF.
@@ -683,9 +637,26 @@ class ClientChannelFilter::SubchannelWrapper final
           state == GRPC_CHANNEL_TRANSIENT_FAILURE ? status : absl::OkStatus());
     }
 
+    void ApplyKeepaliveThrottlingInWorkSerializer(Duration new_keepalive_time)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(*parent_->chand_->work_serializer_) {
+      if (new_keepalive_time > parent_->chand_->keepalive_time_) {
+        parent_->chand_->keepalive_time_ = new_keepalive_time;
+        GRPC_TRACE_LOG(client_channel, INFO)
+            << "chand=" << parent_->chand_ << ": throttling keepalive time to "
+            << parent_->chand_->keepalive_time_;
+        // Propagate the new keepalive time to all subchannels. This is so
+        // that new transports created by any subchannel (and not just the
+        // subchannel that received the GOAWAY), use the new keepalive time.
+        for (auto& [subchannel, _] : parent_->chand_->subchannel_map_) {
+          if (parent_->subchannel_ == subchannel) continue;
+          subchannel->ThrottleKeepaliveTime(new_keepalive_time);
+        }
+      }
+    }
+
     std::unique_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
         watcher_;
-    RefCountedPtr<SubchannelWrapper> parent_;
+    WeakRefCountedPtr<SubchannelWrapper> parent_;
   };
 
   // A heterogenous lookup comparator for data watchers that allows
@@ -708,6 +679,7 @@ class ClientChannelFilter::SubchannelWrapper final
 
   ClientChannelFilter* chand_;
   RefCountedPtr<Subchannel> subchannel_;
+  const uint32_t max_connections_per_subchannel_;
   // Maps from the address of the watcher passed to us by the LB policy
   // to the address of the WrapperWatcher that we passed to the underlying
   // subchannel.  This is needed so that when the LB policy calls
@@ -739,7 +711,7 @@ ClientChannelFilter::ExternalConnectivityWatcher::ExternalConnectivityWatcher(
   {
     MutexLock lock(&chand_->external_watchers_mu_);
     // Will be deleted when the watch is complete.
-    CHECK(chand->external_watchers_[on_complete] == nullptr);
+    GRPC_CHECK(chand->external_watchers_[on_complete] == nullptr);
     // Store a ref to the watcher in the external_watchers_ map.
     chand->external_watchers_[on_complete] =
         RefAsSubclass<ExternalConnectivityWatcher>(
@@ -919,6 +891,17 @@ class ClientChannelFilter::ClientChannelControlHelper final
       const ChannelArgs& args) override
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     if (chand_->resolver_ == nullptr) return nullptr;  // Shutting down.
+    // Determine max_connections_per_subchannel.
+    const uint32_t cap =
+        args.GetInt(GRPC_ARG_MAX_CONNECTIONS_PER_SUBCHANNEL_CAP).value_or(10);
+    uint32_t max_connections_per_subchannel =
+        args.GetInt(GRPC_ARG_MAX_CONNECTIONS_PER_SUBCHANNEL)
+            .value_or(
+                per_address_args.GetInt(GRPC_ARG_MAX_CONNECTIONS_PER_SUBCHANNEL)
+                    .value_or(1));
+    max_connections_per_subchannel =
+        std::min(max_connections_per_subchannel, cap);
+    // Modify args for subchannel.
     ChannelArgs subchannel_args = Subchannel::MakeSubchannelArgs(
         args, per_address_args, chand_->subchannel_pool_,
         chand_->default_authority_);
@@ -930,7 +913,8 @@ class ClientChannelFilter::ClientChannelControlHelper final
     // Make sure the subchannel has updated keepalive time.
     subchannel->ThrottleKeepaliveTime(chand_->keepalive_time_);
     // Create and return wrapper for the subchannel.
-    return MakeRefCounted<SubchannelWrapper>(chand_, std::move(subchannel));
+    return MakeRefCounted<SubchannelWrapper>(chand_, std::move(subchannel),
+                                             max_connections_per_subchannel);
   }
 
   void UpdateState(grpc_connectivity_state state, const absl::Status& status,
@@ -983,24 +967,13 @@ class ClientChannelFilter::ClientChannelControlHelper final
     return **chand_->owning_stack_->stats_plugin_group;
   }
 
-  void AddTraceEvent(TraceSeverity severity, absl::string_view message) override
+  void AddTraceEvent(absl::string_view message) override
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     if (chand_->resolver_ == nullptr) return;  // Shutting down.
-    if (chand_->channelz_node_ != nullptr) {
-      chand_->channelz_node_->AddTraceEvent(
-          ConvertSeverityEnum(severity),
-          grpc_slice_from_copied_buffer(message.data(), message.size()));
-    }
+    GRPC_CHANNELZ_LOG(chand_->channelz_node_) << std::string(message);
   }
 
  private:
-  static channelz::ChannelTrace::Severity ConvertSeverityEnum(
-      TraceSeverity severity) {
-    if (severity == TRACE_INFO) return channelz::ChannelTrace::Info;
-    if (severity == TRACE_WARNING) return channelz::ChannelTrace::Warning;
-    return channelz::ChannelTrace::Error;
-  }
-
   ClientChannelFilter* chand_;
 };
 
@@ -1010,8 +983,8 @@ class ClientChannelFilter::ClientChannelControlHelper final
 
 grpc_error_handle ClientChannelFilter::Init(grpc_channel_element* elem,
                                             grpc_channel_element_args* args) {
-  CHECK(args->is_last);
-  CHECK(elem->filter == &kFilter);
+  GRPC_CHECK(args->is_last);
+  GRPC_CHECK(elem->filter == &kFilter);
   grpc_error_handle error;
   new (elem->channel_data) ClientChannelFilter(args, &error);
   return error;
@@ -1099,9 +1072,7 @@ ClientChannelFilter::ClientChannelFilter(grpc_channel_element_args* args,
   // Set initial keepalive time.
   auto keepalive_arg = channel_args_.GetInt(GRPC_ARG_KEEPALIVE_TIME_MS);
   if (keepalive_arg.has_value()) {
-    keepalive_time_ = Clamp(*keepalive_arg, 1, INT_MAX);
-  } else {
-    keepalive_time_ = -1;  // unset
+    keepalive_time_ = Duration::Milliseconds(Clamp(*keepalive_arg, 1, INT_MAX));
   }
   // Set default authority.
   std::optional<std::string> default_authority =
@@ -1126,16 +1097,15 @@ ClientChannelFilter::~ClientChannelFilter() {
   grpc_pollset_set_destroy(interested_parties_);
 }
 
-OrphanablePtr<ClientChannelFilter::FilterBasedLoadBalancedCall>
+OrphanablePtr<ClientChannelFilter::LoadBalancedCall>
 ClientChannelFilter::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) {
   promise_detail::Context<Arena> arena_ctx(args.arena);
-  return OrphanablePtr<FilterBasedLoadBalancedCall>(
-      args.arena->New<FilterBasedLoadBalancedCall>(
-          this, args, pollent, on_call_destruction_complete,
-          std::move(on_commit), is_transparent_retry));
+  return OrphanablePtr<LoadBalancedCall>(args.arena->New<LoadBalancedCall>(
+      this, args, pollent, on_call_destruction_complete, std::move(on_commit),
+      is_transparent_retry));
 }
 
 void ClientChannelFilter::ReprocessQueuedResolverCalls() {
@@ -1199,7 +1169,7 @@ RefCountedPtr<LoadBalancingPolicy::Config> ChooseLbPolicy(
   // - A channel arg, in which case we check that the specified policy exists
   //   and accepts an empty config. If not, we revert to using pick_first
   //   lb_policy
-  CHECK(lb_policy_config.ok());
+  GRPC_CHECK(lb_policy_config.ok());
   return std::move(*lb_policy_config);
 }
 
@@ -1290,6 +1260,12 @@ void ClientChannelFilter::OnResolverResultChangedLocked(
         static_cast<const internal::ClientChannelGlobalParsedConfig*>(
             service_config->GetGlobalParsedConfig(
                 service_config_parser_index_));
+    // Set max_connections_per_subchannel from service config.
+    if (parsed_service_config->max_connections_per_subchannel() != 0) {
+      result.args = result.args.Set(
+          GRPC_ARG_MAX_CONNECTIONS_PER_SUBCHANNEL,
+          parsed_service_config->max_connections_per_subchannel());
+    }
     // Choose LB policy config.
     RefCountedPtr<LoadBalancingPolicy::Config> lb_policy_config =
         ChooseLbPolicy(result, parsed_service_config);
@@ -1332,12 +1308,8 @@ void ClientChannelFilter::OnResolverResultChangedLocked(
   }
   // Add channel trace event.
   if (!trace_strings.empty()) {
-    std::string message =
-        absl::StrCat("Resolution event: ", absl::StrJoin(trace_strings, ", "));
-    if (channelz_node_ != nullptr) {
-      channelz_node_->AddTraceEvent(channelz::ChannelTrace::Severity::Info,
-                                    grpc_slice_from_cpp_string(message));
-    }
+    GRPC_CHANNELZ_LOG(channelz_node_)
+        << "Resolution event: " << absl::StrJoin(trace_strings, ", ");
   }
 }
 
@@ -1459,18 +1431,20 @@ void ClientChannelFilter::UpdateServiceConfigInDataPlaneLocked(
       !new_args.WantMinimalStack() &&
       new_args.GetBool(GRPC_ARG_ENABLE_RETRIES).value_or(true);
   // Construct dynamic filter stack.
+  auto new_blackboard = MakeRefCounted<Blackboard>();
   std::vector<const grpc_channel_filter*> filters =
-      config_selector->GetFilters();
+      config_selector->GetFilters(blackboard_.get(), new_blackboard.get());
   if (enable_retries) {
+    RetryFilter::UpdateBlackboard(*service_config, blackboard_.get(),
+                                  new_blackboard.get());
     filters.push_back(&RetryFilter::kVtable);
   } else {
     filters.push_back(&DynamicTerminationFilter::kFilterVtable);
   }
-  auto new_blackboard = MakeRefCounted<Blackboard>();
-  RefCountedPtr<DynamicFilters> dynamic_filters = DynamicFilters::Create(
-      new_args, std::move(filters), blackboard_.get(), new_blackboard.get());
-  CHECK(dynamic_filters != nullptr);
   blackboard_ = std::move(new_blackboard);
+  RefCountedPtr<DynamicFilters> dynamic_filters =
+      DynamicFilters::Create(new_args, std::move(filters), blackboard_.get());
+  GRPC_CHECK(dynamic_filters != nullptr);
   // Grab data plane lock to update service config.
   //
   // We defer unreffing the old values (and deallocating memory) until
@@ -1500,7 +1474,7 @@ void ClientChannelFilter::CreateResolverLocked() {
       std::make_unique<ResolverResultHandler>(this));
   // Since the validity of the args was checked when the channel was created,
   // CreateResolver() must return a non-null result.
-  CHECK(resolver_ != nullptr);
+  GRPC_CHECK(resolver_ != nullptr);
   UpdateStateLocked(GRPC_CHANNEL_CONNECTING, absl::Status(),
                     "started resolving");
   resolver_->StartLocked();
@@ -1551,11 +1525,16 @@ void ClientChannelFilter::UpdateStateLocked(grpc_connectivity_state state,
   state_tracker_.SetState(state, status, reason);
   if (channelz_node_ != nullptr) {
     channelz_node_->SetConnectivityState(state);
-    channelz_node_->AddTraceEvent(
-        channelz::ChannelTrace::Severity::Info,
-        grpc_slice_from_static_string(
-            channelz::ChannelNode::GetChannelConnectivityStateChangeString(
-                state)));
+    if (!status.ok() || state == GRPC_CHANNEL_TRANSIENT_FAILURE) {
+      GRPC_CHANNELZ_LOG(channelz_node_)
+          << channelz::ChannelNode::GetChannelConnectivityStateChangeString(
+                 state);
+    } else {
+      GRPC_CHANNELZ_LOG(channelz_node_)
+          << channelz::ChannelNode::GetChannelConnectivityStateChangeString(
+                 state)
+          << " status: " << status.ToString();
+    }
   }
 }
 
@@ -1605,7 +1584,7 @@ T HandlePickResult(
   }
   auto* drop_pick =
       std::get_if<LoadBalancingPolicy::PickResult::Drop>(&result->result);
-  CHECK_NE(drop_pick, nullptr);
+  GRPC_CHECK_NE(drop_pick, nullptr);
   return drop_func(drop_pick);
 }
 
@@ -1698,7 +1677,7 @@ void ClientChannelFilter::StartTransportOpLocked(grpc_transport_op* op) {
       }
     } else {
       // Disconnect.
-      CHECK(disconnect_error_.ok());
+      GRPC_CHECK(disconnect_error_.ok());
       disconnect_error_ = op->disconnect_with_error;
       UpdateStateAndPickerLocked(
           GRPC_CHANNEL_SHUTDOWN, absl::Status(), "shutdown from API",
@@ -1716,7 +1695,7 @@ void ClientChannelFilter::StartTransportOpLocked(grpc_transport_op* op) {
 void ClientChannelFilter::StartTransportOp(grpc_channel_element* elem,
                                            grpc_transport_op* op) {
   auto* chand = static_cast<ClientChannelFilter*>(elem->channel_data);
-  CHECK(op->set_accept_stream == false);
+  GRPC_CHECK(op->set_accept_stream == false);
   // Handle bind_pollset.
   if (op->bind_pollset != nullptr) {
     grpc_pollset_set_add_pollset(chand->interested_parties_, op->bind_pollset);
@@ -1779,6 +1758,52 @@ void ClientChannelFilter::RemoveConnectivityWatcher(
   new ConnectivityWatcherRemover(this, watcher);
 }
 
+//
+// ClientChannelFilter::CallData::ResolverQueuedCallCanceller
+//
+
+// A class to handle the call combiner cancellation callback for a
+// queued pick.
+class ClientChannelFilter::CallData::ResolverQueuedCallCanceller final {
+ public:
+  explicit ResolverQueuedCallCanceller(CallData* calld) : calld_(calld) {
+    GRPC_CALL_STACK_REF(calld->owning_call_, "ResolverQueuedCallCanceller");
+    GRPC_CLOSURE_INIT(&closure_, &CancelLocked, this,
+                      grpc_schedule_on_exec_ctx);
+    calld->call_combiner_->SetNotifyOnCancel(&closure_);
+  }
+
+ private:
+  static void CancelLocked(void* arg, grpc_error_handle error) {
+    auto* self = static_cast<ResolverQueuedCallCanceller*>(arg);
+    auto* calld = self->calld_;
+    auto* chand = calld->chand();
+    {
+      MutexLock lock(&chand->resolution_mu_);
+      GRPC_TRACE_LOG(client_channel_call, INFO)
+          << "chand=" << chand << " calld=" << calld
+          << ": cancelling resolver queued pick: "
+             "error="
+          << StatusToString(error) << " self=" << self
+          << " calld->resolver_pick_canceller="
+          << calld->resolver_call_canceller_;
+      if (calld->resolver_call_canceller_ == self && !error.ok()) {
+        // Remove pick from list of queued picks.
+        calld->RemoveCallFromResolverQueuedCallsLocked();
+        chand->resolver_queued_calls_.erase(calld);
+        // Fail pending batches on the call.
+        calld->buffered_call_.Fail(
+            error, BufferedCall::YieldCallCombinerIfPendingBatchesFound);
+      }
+    }
+    GRPC_CALL_STACK_UNREF(calld->owning_call_, "ResolvingQueuedCallCanceller");
+    delete self;
+  }
+
+  CallData* calld_;
+  grpc_closure closure_;
+};
+
 //
 // CallData implementation
 //
@@ -1788,7 +1813,7 @@ void ClientChannelFilter::CallData::RemoveCallFromResolverQueuedCallsLocked() {
       << "chand=" << chand() << " calld=" << this
       << ": removing from resolver queued picks list";
   // Remove call's pollent from channel's interested_parties.
-  grpc_polling_entity_del_from_pollset_set(pollent(),
+  grpc_polling_entity_del_from_pollset_set(pollent_,
                                            chand()->interested_parties_);
   // Note: There's no need to actually remove the call from the queue
   // here, because that will be done in
@@ -1800,14 +1825,15 @@ void ClientChannelFilter::CallData::AddCallToResolverQueuedCallsLocked() {
   GRPC_TRACE_LOG(client_channel_call, INFO)
       << "chand=" << chand() << " calld=" << this
       << ": adding to resolver queued picks list; pollent="
-      << grpc_polling_entity_string(pollent());
+      << grpc_polling_entity_string(pollent_);
   // Add call's pollent to channel's interested_parties, so that I/O
   // can be done under the call's CQ.
-  grpc_polling_entity_add_to_pollset_set(pollent(),
+  grpc_polling_entity_add_to_pollset_set(pollent_,
                                          chand()->interested_parties_);
   // Add to queue.
   chand()->resolver_queued_calls_.insert(this);
-  OnAddToQueueLocked();
+  // Register call combiner cancellation callback.
+  resolver_call_canceller_ = new ResolverQueuedCallCanceller(this);
 }
 
 grpc_error_handle ClientChannelFilter::CallData::ApplyServiceConfigToCallLocked(
@@ -1822,12 +1848,12 @@ grpc_error_handle ClientChannelFilter::CallData::ApplyServiceConfigToCallLocked(
   // itself in the call context, so that it can be accessed by filters
   // below us in the stack, and it will be cleaned up when the call ends.
   auto* service_config_call_data =
-      arena()->New<ClientChannelServiceConfigCallData>(arena());
+      arena_->New<ClientChannelServiceConfigCallData>(arena_);
   // Use the ConfigSelector to determine the config for the call.
   absl::Status call_config_status =
       (*config_selector)
           ->GetCallConfig(
-              {send_initial_metadata(), arena(), service_config_call_data});
+              {send_initial_metadata(), arena_, service_config_call_data});
   if (!call_config_status.ok()) {
     return absl_status_to_grpc_error(
         MaybeRewriteIllegalStatusCode(call_config_status, "ConfigSelector"));
@@ -1878,7 +1904,7 @@ std::optional<absl::Status> ClientChannelFilter::CallData::CheckResolution(
   }
   // If the call was queued, add trace annotation.
   if (was_queued) {
-    auto* call_tracer = arena()->GetContext<CallTracerAnnotationInterface>();
+    auto* call_tracer = arena_->GetContext<CallSpan>();
     if (call_tracer != nullptr) {
       call_tracer->RecordAnnotation("Delayed name resolution complete.");
     }
@@ -1916,42 +1942,32 @@ bool ClientChannelFilter::CallData::CheckResolutionLocked(
   return true;
 }
 
-//
-// FilterBasedCallData implementation
-//
-
-ClientChannelFilter::FilterBasedCallData::FilterBasedCallData(
-    grpc_call_element* elem, const grpc_call_element_args& args)
+ClientChannelFilter::CallData::CallData(grpc_call_element* elem,
+                                        const grpc_call_element_args& args)
     : call_start_time_(args.start_time),
       deadline_(args.deadline),
       arena_(args.arena),
       elem_(elem),
       owning_call_(args.call_stack),
-      call_combiner_(args.call_combiner) {
+      call_combiner_(args.call_combiner),
+      buffered_call_(call_combiner_, &client_channel_call_trace) {
   GRPC_TRACE_LOG(client_channel_call, INFO)
       << "chand=" << chand() << " calld=" << this << ": created call";
 }
 
-ClientChannelFilter::FilterBasedCallData::~FilterBasedCallData() {
-  // Make sure there are no remaining pending batches.
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-    CHECK_EQ(pending_batches_[i], nullptr);
-  }
-}
-
-grpc_error_handle ClientChannelFilter::FilterBasedCallData::Init(
+grpc_error_handle ClientChannelFilter::CallData::Init(
     grpc_call_element* elem, const grpc_call_element_args* args) {
-  new (elem->call_data) FilterBasedCallData(elem, *args);
+  new (elem->call_data) CallData(elem, *args);
   return absl::OkStatus();
 }
 
-void ClientChannelFilter::FilterBasedCallData::Destroy(
+void ClientChannelFilter::CallData::Destroy(
     grpc_call_element* elem, const grpc_call_final_info* /*final_info*/,
     grpc_closure* then_schedule_closure) {
-  auto* calld = static_cast<FilterBasedCallData*>(elem->call_data);
+  auto* calld = static_cast<CallData*>(elem->call_data);
   RefCountedPtr<DynamicFilters::Call> dynamic_call =
       std::move(calld->dynamic_call_);
-  calld->~FilterBasedCallData();
+  calld->~CallData();
   if (GPR_LIKELY(dynamic_call != nullptr)) {
     dynamic_call->SetAfterCallStackDestroy(then_schedule_closure);
   } else {
@@ -1960,9 +1976,9 @@ void ClientChannelFilter::FilterBasedCallData::Destroy(
   }
 }
 
-void ClientChannelFilter::FilterBasedCallData::StartTransportStreamOpBatch(
+void ClientChannelFilter::CallData::StartTransportStreamOpBatch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
-  auto* calld = static_cast<FilterBasedCallData*>(elem->call_data);
+  auto* calld = static_cast<CallData*>(elem->call_data);
   auto* chand = static_cast<ClientChannelFilter*>(elem->channel_data);
   if (GRPC_TRACE_FLAG_ENABLED(client_channel_call) &&
       !GRPC_TRACE_FLAG_ENABLED(channel)) {
@@ -2001,7 +2017,7 @@ void ClientChannelFilter::FilterBasedCallData::StartTransportStreamOpBatch(
         << StatusToString(calld->cancel_error_);
     // Note: This will release the call combiner.
     grpc_transport_stream_op_batch_finish_with_failure(
-        batch, calld->cancel_error_, calld->call_combiner());
+        batch, calld->cancel_error_, calld->call_combiner_);
     return;
   }
   // Handle cancellation.
@@ -2016,14 +2032,15 @@ void ClientChannelFilter::FilterBasedCallData::StartTransportStreamOpBatch(
         << "chand=" << chand << " calld=" << calld
         << ": recording cancel_error=" << StatusToString(calld->cancel_error_);
     // Fail all pending batches.
-    calld->PendingBatchesFail(calld->cancel_error_, NoYieldCallCombiner);
+    calld->buffered_call_.Fail(calld->cancel_error_,
+                               BufferedCall::NoYieldCallCombiner);
     // Note: This will release the call combiner.
     grpc_transport_stream_op_batch_finish_with_failure(
-        batch, calld->cancel_error_, calld->call_combiner());
+        batch, calld->cancel_error_, calld->call_combiner_);
     return;
   }
   // Add the batch to the pending list.
-  calld->PendingBatchesAdd(batch);
+  calld->buffered_call_.EnqueueBatch(batch);
   // For batches containing a send_initial_metadata op, acquire the
   // channel's resolution mutex to apply the service config to the call,
   // after which we will create a dynamic call.
@@ -2051,188 +2068,29 @@ void ClientChannelFilter::FilterBasedCallData::StartTransportStreamOpBatch(
     GRPC_TRACE_LOG(client_channel_call, INFO)
         << "chand=" << chand << " calld=" << calld
         << ": saved batch, yielding call combiner";
-    GRPC_CALL_COMBINER_STOP(calld->call_combiner(),
+    GRPC_CALL_COMBINER_STOP(calld->call_combiner_,
                             "batch does not include send_initial_metadata");
   }
 }
 
-void ClientChannelFilter::FilterBasedCallData::SetPollent(
-    grpc_call_element* elem, grpc_polling_entity* pollent) {
-  auto* calld = static_cast<FilterBasedCallData*>(elem->call_data);
+void ClientChannelFilter::CallData::SetPollent(grpc_call_element* elem,
+                                               grpc_polling_entity* pollent) {
+  auto* calld = static_cast<CallData*>(elem->call_data);
   calld->pollent_ = pollent;
 }
 
-size_t ClientChannelFilter::FilterBasedCallData::GetBatchIndex(
-    grpc_transport_stream_op_batch* batch) {
-  // Note: It is important the send_initial_metadata be the first entry
-  // here, since the code in CheckResolution() assumes it will be.
-  if (batch->send_initial_metadata) return 0;
-  if (batch->send_message) return 1;
-  if (batch->send_trailing_metadata) return 2;
-  if (batch->recv_initial_metadata) return 3;
-  if (batch->recv_message) return 4;
-  if (batch->recv_trailing_metadata) return 5;
-  GPR_UNREACHABLE_CODE(return (size_t)-1);
-}
-
-// This is called via the call combiner, so access to calld is synchronized.
-void ClientChannelFilter::FilterBasedCallData::PendingBatchesAdd(
-    grpc_transport_stream_op_batch* batch) {
-  const size_t idx = GetBatchIndex(batch);
-  GRPC_TRACE_LOG(client_channel_call, INFO)
-      << "chand=" << chand() << " calld=" << this
-      << ": adding pending batch at index " << idx;
-  grpc_transport_stream_op_batch*& pending = pending_batches_[idx];
-  CHECK_EQ(pending, nullptr);
-  pending = batch;
-}
-
-// This is called via the call combiner, so access to calld is synchronized.
-void ClientChannelFilter::FilterBasedCallData::FailPendingBatchInCallCombiner(
-    void* arg, grpc_error_handle error) {
-  grpc_transport_stream_op_batch* batch =
-      static_cast<grpc_transport_stream_op_batch*>(arg);
-  auto* calld =
-      static_cast<FilterBasedCallData*>(batch->handler_private.extra_arg);
-  // Note: This will release the call combiner.
-  grpc_transport_stream_op_batch_finish_with_failure(batch, error,
-                                                     calld->call_combiner());
-}
-
-// This is called via the call combiner, so access to calld is synchronized.
-void ClientChannelFilter::FilterBasedCallData::PendingBatchesFail(
-    grpc_error_handle error,
-    YieldCallCombinerPredicate yield_call_combiner_predicate) {
-  CHECK(!error.ok());
-  if (GRPC_TRACE_FLAG_ENABLED(client_channel_call)) {
-    size_t num_batches = 0;
-    for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-      if (pending_batches_[i] != nullptr) ++num_batches;
-    }
-    LOG(INFO) << "chand=" << chand() << " calld=" << this << ": failing "
-              << num_batches << " pending batches: " << StatusToString(error);
-  }
-  CallCombinerClosureList closures;
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-    grpc_transport_stream_op_batch*& batch = pending_batches_[i];
-    if (batch != nullptr) {
-      batch->handler_private.extra_arg = this;
-      GRPC_CLOSURE_INIT(&batch->handler_private.closure,
-                        FailPendingBatchInCallCombiner, batch,
-                        grpc_schedule_on_exec_ctx);
-      closures.Add(&batch->handler_private.closure, error,
-                   "PendingBatchesFail");
-      batch = nullptr;
-    }
-  }
-  if (yield_call_combiner_predicate(closures)) {
-    closures.RunClosures(call_combiner());
-  } else {
-    closures.RunClosuresWithoutYielding(call_combiner());
-  }
-}
-
-// This is called via the call combiner, so access to calld is synchronized.
-void ClientChannelFilter::FilterBasedCallData::ResumePendingBatchInCallCombiner(
-    void* arg, grpc_error_handle /*ignored*/) {
-  grpc_transport_stream_op_batch* batch =
-      static_cast<grpc_transport_stream_op_batch*>(arg);
-  auto* calld =
-      static_cast<FilterBasedCallData*>(batch->handler_private.extra_arg);
-  // Note: This will release the call combiner.
-  calld->dynamic_call_->StartTransportStreamOpBatch(batch);
-}
-
-// This is called via the call combiner, so access to calld is synchronized.
-void ClientChannelFilter::FilterBasedCallData::PendingBatchesResume() {
-  // Retries not enabled; send down batches as-is.
-  if (GRPC_TRACE_FLAG_ENABLED(client_channel_call)) {
-    size_t num_batches = 0;
-    for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-      if (pending_batches_[i] != nullptr) ++num_batches;
-    }
-    LOG(INFO) << "chand=" << chand() << " calld=" << this << ": starting "
-              << num_batches
-              << " pending batches on dynamic_call=" << dynamic_call_.get();
-  }
-  CallCombinerClosureList closures;
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-    grpc_transport_stream_op_batch*& batch = pending_batches_[i];
-    if (batch != nullptr) {
-      batch->handler_private.extra_arg = this;
-      GRPC_CLOSURE_INIT(&batch->handler_private.closure,
-                        ResumePendingBatchInCallCombiner, batch, nullptr);
-      closures.Add(&batch->handler_private.closure, absl::OkStatus(),
-                   "resuming pending batch from client channel call");
-      batch = nullptr;
-    }
-  }
-  // Note: This will release the call combiner.
-  closures.RunClosures(call_combiner());
-}
-
-// A class to handle the call combiner cancellation callback for a
-// queued pick.
-class ClientChannelFilter::FilterBasedCallData::ResolverQueuedCallCanceller
-    final {
- public:
-  explicit ResolverQueuedCallCanceller(FilterBasedCallData* calld)
-      : calld_(calld) {
-    GRPC_CALL_STACK_REF(calld->owning_call(), "ResolverQueuedCallCanceller");
-    GRPC_CLOSURE_INIT(&closure_, &CancelLocked, this,
-                      grpc_schedule_on_exec_ctx);
-    calld->call_combiner()->SetNotifyOnCancel(&closure_);
-  }
-
- private:
-  static void CancelLocked(void* arg, grpc_error_handle error) {
-    auto* self = static_cast<ResolverQueuedCallCanceller*>(arg);
-    auto* calld = self->calld_;
-    auto* chand = calld->chand();
-    {
-      MutexLock lock(&chand->resolution_mu_);
-      GRPC_TRACE_LOG(client_channel_call, INFO)
-          << "chand=" << chand << " calld=" << calld
-          << ": cancelling resolver queued pick: "
-             "error="
-          << StatusToString(error) << " self=" << self
-          << " calld->resolver_pick_canceller="
-          << calld->resolver_call_canceller_;
-      if (calld->resolver_call_canceller_ == self && !error.ok()) {
-        // Remove pick from list of queued picks.
-        calld->RemoveCallFromResolverQueuedCallsLocked();
-        chand->resolver_queued_calls_.erase(calld);
-        // Fail pending batches on the call.
-        calld->PendingBatchesFail(error,
-                                  YieldCallCombinerIfPendingBatchesFound);
-      }
-    }
-    GRPC_CALL_STACK_UNREF(calld->owning_call(), "ResolvingQueuedCallCanceller");
-    delete self;
-  }
-
-  FilterBasedCallData* calld_;
-  grpc_closure closure_;
-};
-
-void ClientChannelFilter::FilterBasedCallData::TryCheckResolution(
-    bool was_queued) {
+void ClientChannelFilter::CallData::TryCheckResolution(bool was_queued) {
   auto result = CheckResolution(was_queued);
   if (result.has_value()) {
     if (!result->ok()) {
-      PendingBatchesFail(*result, YieldCallCombiner);
+      buffered_call_.Fail(*result, BufferedCall::YieldCallCombiner);
       return;
     }
     CreateDynamicCall();
   }
 }
 
-void ClientChannelFilter::FilterBasedCallData::OnAddToQueueLocked() {
-  // Register call combiner cancellation callback.
-  resolver_call_canceller_ = new ResolverQueuedCallCanceller(this);
-}
-
-void ClientChannelFilter::FilterBasedCallData::RetryCheckResolutionLocked() {
+void ClientChannelFilter::CallData::RetryCheckResolutionLocked() {
   // Lame the call combiner canceller.
   resolver_call_canceller_ = nullptr;
   // Do an async callback to resume call processing, so that we're not
@@ -2243,10 +2101,10 @@ void ClientChannelFilter::FilterBasedCallData::RetryCheckResolutionLocked() {
   });
 }
 
-void ClientChannelFilter::FilterBasedCallData::CreateDynamicCall() {
-  DynamicFilters::Call::Args args = {dynamic_filters(), pollent_,
-                                     call_start_time_,  deadline_,
-                                     arena(),           call_combiner()};
+void ClientChannelFilter::CallData::CreateDynamicCall() {
+  DynamicFilters::Call::Args args = {dynamic_filters_, pollent_,
+                                     call_start_time_, deadline_,
+                                     arena_,           call_combiner_};
   grpc_error_handle error;
   DynamicFilters* channel_stack = args.channel_stack.get();
   GRPC_TRACE_LOG(client_channel_call, INFO)
@@ -2257,18 +2115,21 @@ void ClientChannelFilter::FilterBasedCallData::CreateDynamicCall() {
     GRPC_TRACE_LOG(client_channel_call, INFO)
         << "chand=" << chand() << " calld=" << this
         << ": failed to create dynamic call: error=" << StatusToString(error);
-    PendingBatchesFail(error, YieldCallCombiner);
+    buffered_call_.Fail(error, BufferedCall::YieldCallCombiner);
     return;
   }
-  PendingBatchesResume();
+  buffered_call_.Resume(
+      [dynamic_call = dynamic_call_](grpc_transport_stream_op_batch* batch) {
+        dynamic_call->StartTransportStreamOpBatch(batch);
+      });
 }
 
-void ClientChannelFilter::FilterBasedCallData::
+void ClientChannelFilter::CallData::
     RecvTrailingMetadataReadyForConfigSelectorCommitCallback(
         void* arg, grpc_error_handle error) {
-  auto* calld = static_cast<FilterBasedCallData*>(arg);
+  auto* calld = static_cast<CallData*>(arg);
   auto* chand = calld->chand();
-  auto* service_config_call_data = GetServiceConfigCallData(calld->arena());
+  auto* service_config_call_data = GetServiceConfigCallData(calld->arena_);
   GRPC_TRACE_LOG(client_channel_call, INFO)
       << "chand=" << chand << " calld=" << calld
       << ": got recv_trailing_metadata_ready: error=" << StatusToString(error)
@@ -2297,7 +2158,7 @@ class ClientChannelFilter::LoadBalancedCall::LbCallState final
   ServiceConfigCallData::CallAttributeInterface* GetCallAttribute(
       UniqueTypeName type) const override;
 
-  ClientCallTracer::CallAttemptTracer* GetCallAttemptTracer() const override;
+  CallAttemptTracer* GetCallAttemptTracer() const override;
 
  private:
   LoadBalancedCall* lb_call_;
@@ -2314,10 +2175,10 @@ ClientChannelFilter::LoadBalancedCall::LbCallState::GetCallAttribute(
   return service_config_call_data->GetCallAttribute(type);
 }
 
-ClientCallTracer::CallAttemptTracer*
+CallAttemptTracer*
 ClientChannelFilter::LoadBalancedCall::LbCallState::GetCallAttemptTracer()
     const {
-  return lb_call_->call_attempt_tracer();
+  return lb_call_->call_attempt_tracer_;
 }
 
 //
@@ -2365,35 +2226,96 @@ class ClientChannelFilter::LoadBalancedCall::BackendMetricAccessor final
   grpc_metadata_batch* recv_trailing_metadata_;
 };
 
+//
+// ClientChannelFilter::LoadBalancedCall::LbQueuedCallCanceller
+//
+
+// A class to handle the call combiner cancellation callback for a
+// queued pick.
+// TODO(roth): When we implement hedging support, we won't be able to
+// register a call combiner cancellation closure for each LB pick,
+// because there may be multiple LB picks happening in parallel.
+// Instead, we will probably need to maintain a list in the CallData
+// object of pending LB picks to be cancelled when the closure runs.
+class ClientChannelFilter::LoadBalancedCall::LbQueuedCallCanceller final {
+ public:
+  explicit LbQueuedCallCanceller(RefCountedPtr<LoadBalancedCall> lb_call)
+      : lb_call_(std::move(lb_call)) {
+    GRPC_CALL_STACK_REF(lb_call_->owning_call_, "LbQueuedCallCanceller");
+    GRPC_CLOSURE_INIT(&closure_, &CancelLocked, this, nullptr);
+    lb_call_->call_combiner_->SetNotifyOnCancel(&closure_);
+  }
+
+ private:
+  static void CancelLocked(void* arg, grpc_error_handle error) {
+    auto* self = static_cast<LbQueuedCallCanceller*>(arg);
+    auto* lb_call = self->lb_call_.get();
+    auto* chand = lb_call->chand_;
+    {
+      MutexLock lock(&chand->lb_mu_);
+      GRPC_TRACE_LOG(client_channel_lb_call, INFO)
+          << "chand=" << chand << " lb_call=" << lb_call
+          << ": cancelling queued pick: error=" << StatusToString(error)
+          << " self=" << self
+          << " calld->pick_canceller=" << lb_call->lb_call_canceller_;
+      if (lb_call->lb_call_canceller_ == self && !error.ok()) {
+        lb_call->Commit();
+        // Remove pick from list of queued picks.
+        lb_call->RemoveCallFromLbQueuedCallsLocked();
+        // Remove from queued picks list.
+        chand->lb_queued_calls_.erase(self->lb_call_);
+        // Fail pending batches on the call.
+        lb_call->buffered_call_.Fail(
+            error, BufferedCall::YieldCallCombinerIfPendingBatchesFound);
+      }
+    }
+    // Unref lb_call before unreffing the call stack, since unreffing
+    // the call stack may destroy the arena in which lb_call is allocated.
+    auto* owning_call = lb_call->owning_call_;
+    self->lb_call_.reset();
+    GRPC_CALL_STACK_UNREF(owning_call, "LbQueuedCallCanceller");
+    delete self;
+  }
+
+  RefCountedPtr<LoadBalancedCall> lb_call_;
+  grpc_closure closure_;
+};
+
 //
 // ClientChannelFilter::LoadBalancedCall
 //
 
 namespace {
 
-ClientCallTracer::CallAttemptTracer* CreateCallAttemptTracer(
-    Arena* arena, bool is_transparent_retry) {
-  auto* call_tracer = DownCast<ClientCallTracer*>(
-      arena->GetContext<CallTracerAnnotationInterface>());
+CallAttemptTracer* CreateCallAttemptTracer(Arena* arena,
+                                           bool is_transparent_retry) {
+  auto* call_tracer = arena->GetContext<ClientCallTracer>();
   if (call_tracer == nullptr) return nullptr;
-  auto* tracer = call_tracer->StartNewAttempt(is_transparent_retry);
-  arena->SetContext<CallTracerInterface>(tracer);
+  auto* tracer = WrapCallAttemptTracer(
+      call_tracer->StartNewAttempt(is_transparent_retry), arena);
+  arena->SetContext<CallTracer>(tracer);
   return tracer;
 }
 
 }  // namespace
 
 ClientChannelFilter::LoadBalancedCall::LoadBalancedCall(
-    ClientChannelFilter* chand, Arena* arena,
+    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)
     : InternallyRefCounted(GRPC_TRACE_FLAG_ENABLED(client_channel_lb_call)
                                ? "LoadBalancedCall"
                                : nullptr),
       chand_(chand),
       call_attempt_tracer_(
-          CreateCallAttemptTracer(arena, is_transparent_retry)),
+          CreateCallAttemptTracer(args.arena, is_transparent_retry)),
+      owning_call_(args.call_stack),
+      call_combiner_(args.call_combiner),
+      pollent_(pollent),
+      on_call_destruction_complete_(on_call_destruction_complete),
+      arena_(args.arena),
       on_commit_(std::move(on_commit)),
-      arena_(arena) {
+      buffered_call_(call_combiner_, &client_channel_lb_call_trace) {
   GRPC_TRACE_LOG(client_channel_lb_call, INFO)
       << "chand=" << chand_ << " lb_call=" << this << ": created";
 }
@@ -2402,6 +2324,22 @@ ClientChannelFilter::LoadBalancedCall::~LoadBalancedCall() {
   if (backend_metric_data_ != nullptr) {
     backend_metric_data_->BackendMetricData::~BackendMetricData();
   }
+  if (on_call_destruction_complete_ != nullptr) {
+    ExecCtx::Run(DEBUG_LOCATION, on_call_destruction_complete_,
+                 absl::OkStatus());
+  }
+}
+
+void ClientChannelFilter::LoadBalancedCall::Orphan() {
+  // If the recv_trailing_metadata op was never started, then notify
+  // about call completion here, as best we can.  We assume status
+  // CANCELLED in this case.
+  if (recv_trailing_metadata_ == nullptr) {
+    RecordCallCompletion(absl::CancelledError("call cancelled"), nullptr,
+                         nullptr, "");
+  }
+  RecordLatency();
+  Unref();
 }
 
 void ClientChannelFilter::LoadBalancedCall::RecordCallCompletion(
@@ -2409,8 +2347,8 @@ void ClientChannelFilter::LoadBalancedCall::RecordCallCompletion(
     grpc_transport_stream_stats* transport_stream_stats,
     absl::string_view peer_address) {
   // If we have a tracer, notify it.
-  if (call_attempt_tracer() != nullptr) {
-    call_attempt_tracer()->RecordReceivedTrailingMetadata(
+  if (call_attempt_tracer_ != nullptr) {
+    call_attempt_tracer_->RecordReceivedTrailingMetadata(
         status, recv_trailing_metadata, transport_stream_stats);
   }
   // If the LB policy requested a callback for trailing metadata, invoke
@@ -2427,10 +2365,8 @@ void ClientChannelFilter::LoadBalancedCall::RecordCallCompletion(
 
 void ClientChannelFilter::LoadBalancedCall::RecordLatency() {
   // Compute latency and report it to the tracer.
-  if (call_attempt_tracer() != nullptr) {
-    gpr_timespec latency =
-        gpr_cycle_counter_sub(gpr_get_cycle_counter(), lb_call_start_time_);
-    call_attempt_tracer()->RecordEnd(latency);
+  if (call_attempt_tracer_ != nullptr) {
+    call_attempt_tracer_->RecordEnd();
   }
 }
 
@@ -2440,7 +2376,7 @@ void ClientChannelFilter::LoadBalancedCall::
       << "chand=" << chand_ << " lb_call=" << this
       << ": removing from queued picks list";
   // Remove pollset_set linkage.
-  grpc_polling_entity_del_from_pollset_set(pollent(),
+  grpc_polling_entity_del_from_pollset_set(pollent_,
                                            chand_->interested_parties_);
   // Note: There's no need to actually remove the call from the queue
   // here, because that will be done in either
@@ -2454,11 +2390,12 @@ void ClientChannelFilter::LoadBalancedCall::AddCallToLbQueuedCallsLocked() {
       << ": adding to queued picks list";
   // Add call's pollent to channel's interested_parties, so that I/O
   // can be done under the call's CQ.
-  grpc_polling_entity_add_to_pollset_set(pollent(),
-                                         chand_->interested_parties_);
+  grpc_polling_entity_add_to_pollset_set(pollent_, chand_->interested_parties_);
   // Add to queue.
   chand_->lb_queued_calls_.insert(Ref());
-  OnAddToQueueLocked();
+  // Register call combiner cancellation callback.
+  lb_call_canceller_ =
+      new LbQueuedCallCanceller(RefAsSubclass<LoadBalancedCall>());
 }
 
 std::optional<absl::Status>
@@ -2506,8 +2443,8 @@ ClientChannelFilter::LoadBalancedCall::PickSubchannel(bool was_queued) {
     }
     // Pick is complete.
     // If it was queued, add a trace annotation.
-    if (was_queued && call_attempt_tracer() != nullptr) {
-      call_attempt_tracer()->RecordAnnotation("Delayed LB pick complete.");
+    if (was_queued && call_attempt_tracer_ != nullptr) {
+      call_attempt_tracer_->RecordAnnotation("Delayed LB pick complete.");
     }
     // If the pick failed, fail the call.
     if (!error.ok()) {
@@ -2524,11 +2461,11 @@ ClientChannelFilter::LoadBalancedCall::PickSubchannel(bool was_queued) {
 
 bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
     LoadBalancingPolicy::SubchannelPicker* picker, grpc_error_handle* error) {
-  CHECK(connected_subchannel_ == nullptr);
+  GRPC_CHECK(connected_subchannel_ == nullptr);
   // Perform LB pick.
   LoadBalancingPolicy::PickArgs pick_args;
   Slice* path = send_initial_metadata()->get_pointer(HttpPathMetadata());
-  CHECK_NE(path, nullptr);
+  GRPC_CHECK_NE(path, nullptr);
   pick_args.path = path->as_string_view();
   LbCallState lb_call_state(this);
   pick_args.call_state = &lb_call_state;
@@ -2543,7 +2480,7 @@ bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
             << "chand=" << chand_ << " lb_call=" << this
             << ": LB pick succeeded: subchannel="
             << complete_pick->subchannel.get();
-        CHECK(complete_pick->subchannel != nullptr);
+        GRPC_CHECK(complete_pick->subchannel != nullptr);
         // Grab a ref to the connected subchannel while we're still
         // holding the data plane mutex.
         SubchannelWrapper* subchannel =
@@ -2562,9 +2499,6 @@ bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
         }
         lb_subchannel_call_tracker_ =
             std::move(complete_pick->subchannel_call_tracker);
-        if (lb_subchannel_call_tracker_ != nullptr) {
-          lb_subchannel_call_tracker_->Start();
-        }
         // Handle metadata mutations.
         MetadataMutationHandler::Apply(complete_pick->metadata_mutations,
                                        send_initial_metadata());
@@ -2609,177 +2543,28 @@ bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
       });
 }
 
-//
-// ClientChannelFilter::FilterBasedLoadBalancedCall
-//
-
-ClientChannelFilter::FilterBasedLoadBalancedCall::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)
-    : LoadBalancedCall(chand, args.arena, std::move(on_commit),
-                       is_transparent_retry),
-      owning_call_(args.call_stack),
-      call_combiner_(args.call_combiner),
-      pollent_(pollent),
-      on_call_destruction_complete_(on_call_destruction_complete) {}
-
-ClientChannelFilter::FilterBasedLoadBalancedCall::
-    ~FilterBasedLoadBalancedCall() {
-  // Make sure there are no remaining pending batches.
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-    CHECK_EQ(pending_batches_[i], nullptr);
-  }
-  if (on_call_destruction_complete_ != nullptr) {
-    ExecCtx::Run(DEBUG_LOCATION, on_call_destruction_complete_,
-                 absl::OkStatus());
-  }
-}
-
-void ClientChannelFilter::FilterBasedLoadBalancedCall::Orphan() {
-  // If the recv_trailing_metadata op was never started, then notify
-  // about call completion here, as best we can.  We assume status
-  // CANCELLED in this case.
-  if (recv_trailing_metadata_ == nullptr) {
-    RecordCallCompletion(absl::CancelledError("call cancelled"), nullptr,
-                         nullptr, "");
-  }
-  RecordLatency();
-  // Delegate to parent.
-  LoadBalancedCall::Orphan();
-}
-
-size_t ClientChannelFilter::FilterBasedLoadBalancedCall::GetBatchIndex(
-    grpc_transport_stream_op_batch* batch) {
-  // Note: It is important the send_initial_metadata be the first entry
-  // here, since the code in PickSubchannelImpl() assumes it will be.
-  if (batch->send_initial_metadata) return 0;
-  if (batch->send_message) return 1;
-  if (batch->send_trailing_metadata) return 2;
-  if (batch->recv_initial_metadata) return 3;
-  if (batch->recv_message) return 4;
-  if (batch->recv_trailing_metadata) return 5;
-  GPR_UNREACHABLE_CODE(return (size_t)-1);
-}
-
-// This is called via the call combiner, so access to calld is synchronized.
-void ClientChannelFilter::FilterBasedLoadBalancedCall::PendingBatchesAdd(
+void ClientChannelFilter::LoadBalancedCall::StartTransportStreamOpBatch(
     grpc_transport_stream_op_batch* batch) {
-  const size_t idx = GetBatchIndex(batch);
-  GRPC_TRACE_LOG(client_channel_lb_call, INFO)
-      << "chand=" << chand() << " lb_call=" << this
-      << ": adding pending batch at index " << idx;
-  CHECK_EQ(pending_batches_[idx], nullptr);
-  pending_batches_[idx] = batch;
-}
-
-// This is called via the call combiner, so access to calld is synchronized.
-void ClientChannelFilter::FilterBasedLoadBalancedCall::
-    FailPendingBatchInCallCombiner(void* arg, grpc_error_handle error) {
-  grpc_transport_stream_op_batch* batch =
-      static_cast<grpc_transport_stream_op_batch*>(arg);
-  auto* self = static_cast<FilterBasedLoadBalancedCall*>(
-      batch->handler_private.extra_arg);
-  // Note: This will release the call combiner.
-  grpc_transport_stream_op_batch_finish_with_failure(batch, error,
-                                                     self->call_combiner_);
-}
-
-// This is called via the call combiner, so access to calld is synchronized.
-void ClientChannelFilter::FilterBasedLoadBalancedCall::PendingBatchesFail(
-    grpc_error_handle error,
-    YieldCallCombinerPredicate yield_call_combiner_predicate) {
-  CHECK(!error.ok());
-  failure_error_ = error;
-  if (GRPC_TRACE_FLAG_ENABLED(client_channel_lb_call)) {
-    size_t num_batches = 0;
-    for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-      if (pending_batches_[i] != nullptr) ++num_batches;
-    }
-    LOG(INFO) << "chand=" << chand() << " lb_call=" << this << ": failing "
-              << num_batches << " pending batches: " << StatusToString(error);
-  }
-  CallCombinerClosureList closures;
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-    grpc_transport_stream_op_batch*& batch = pending_batches_[i];
-    if (batch != nullptr) {
-      batch->handler_private.extra_arg = this;
-      GRPC_CLOSURE_INIT(&batch->handler_private.closure,
-                        FailPendingBatchInCallCombiner, batch,
-                        grpc_schedule_on_exec_ctx);
-      closures.Add(&batch->handler_private.closure, error,
-                   "PendingBatchesFail");
-      batch = nullptr;
-    }
-  }
-  if (yield_call_combiner_predicate(closures)) {
-    closures.RunClosures(call_combiner_);
-  } else {
-    closures.RunClosuresWithoutYielding(call_combiner_);
-  }
-}
-
-// This is called via the call combiner, so access to calld is synchronized.
-void ClientChannelFilter::FilterBasedLoadBalancedCall::
-    ResumePendingBatchInCallCombiner(void* arg, grpc_error_handle /*ignored*/) {
-  grpc_transport_stream_op_batch* batch =
-      static_cast<grpc_transport_stream_op_batch*>(arg);
-  SubchannelCall* subchannel_call =
-      static_cast<SubchannelCall*>(batch->handler_private.extra_arg);
-  // Note: This will release the call combiner.
-  subchannel_call->StartTransportStreamOpBatch(batch);
-}
-
-// This is called via the call combiner, so access to calld is synchronized.
-void ClientChannelFilter::FilterBasedLoadBalancedCall::PendingBatchesResume() {
-  if (GRPC_TRACE_FLAG_ENABLED(client_channel_lb_call)) {
-    size_t num_batches = 0;
-    for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-      if (pending_batches_[i] != nullptr) ++num_batches;
-    }
-    LOG(INFO) << "chand=" << chand() << " lb_call=" << this << ": starting "
-              << num_batches << " pending batches on subchannel_call="
-              << subchannel_call_.get();
-  }
-  CallCombinerClosureList closures;
-  for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-    grpc_transport_stream_op_batch*& batch = pending_batches_[i];
-    if (batch != nullptr) {
-      batch->handler_private.extra_arg = subchannel_call_.get();
-      GRPC_CLOSURE_INIT(&batch->handler_private.closure,
-                        ResumePendingBatchInCallCombiner, batch,
-                        grpc_schedule_on_exec_ctx);
-      closures.Add(&batch->handler_private.closure, absl::OkStatus(),
-                   "resuming pending batch from LB call");
-      batch = nullptr;
-    }
-  }
-  // Note: This will release the call combiner.
-  closures.RunClosures(call_combiner_);
-}
-
-void ClientChannelFilter::FilterBasedLoadBalancedCall::
-    StartTransportStreamOpBatch(grpc_transport_stream_op_batch* batch) {
   if (GRPC_TRACE_FLAG_ENABLED(client_channel_lb_call) ||
       GRPC_TRACE_FLAG_ENABLED(channel)) {
-    LOG(INFO) << "chand=" << chand() << " lb_call=" << this
+    LOG(INFO) << "chand=" << chand_ << " lb_call=" << this
               << ": batch started from above: "
               << grpc_transport_stream_op_batch_string(batch, false)
-              << ", call_attempt_tracer()=" << call_attempt_tracer();
+              << ", call_attempt_tracer_=" << call_attempt_tracer_;
   }
   // Handle call tracing.
-  if (call_attempt_tracer() != nullptr) {
+  if (call_attempt_tracer_ != nullptr) {
     // Record send ops in tracer.
     if (batch->cancel_stream) {
-      call_attempt_tracer()->RecordCancel(
+      call_attempt_tracer_->RecordCancel(
           batch->payload->cancel_stream.cancel_error);
     }
     if (batch->send_initial_metadata) {
-      call_attempt_tracer()->RecordSendInitialMetadata(
+      call_attempt_tracer_->RecordSendInitialMetadata(
           batch->payload->send_initial_metadata.send_initial_metadata);
     }
     if (batch->send_trailing_metadata) {
-      call_attempt_tracer()->RecordSendTrailingMetadata(
+      call_attempt_tracer_->RecordSendTrailingMetadata(
           batch->payload->send_trailing_metadata.send_trailing_metadata);
     }
     // Intercept recv ops.
@@ -2814,7 +2599,7 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
   // streaming calls).
   if (subchannel_call_ != nullptr) {
     GRPC_TRACE_LOG(client_channel_lb_call, INFO)
-        << "chand=" << chand() << " lb_call=" << this
+        << "chand=" << chand_ << " lb_call=" << this
         << ": starting batch on subchannel_call=" << subchannel_call_.get();
     subchannel_call_->StartTransportStreamOpBatch(batch);
     return;
@@ -2824,7 +2609,7 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
   // If we've previously been cancelled, immediately fail any new batches.
   if (GPR_UNLIKELY(!cancel_error_.ok())) {
     GRPC_TRACE_LOG(client_channel_lb_call, INFO)
-        << "chand=" << chand() << " lb_call=" << this
+        << "chand=" << chand_ << " lb_call=" << this
         << ": failing batch with error: " << StatusToString(cancel_error_);
     // Note: This will release the call combiner.
     grpc_transport_stream_op_batch_finish_with_failure(batch, cancel_error_,
@@ -2840,17 +2625,17 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
     // error to the caller when the first batch does get passed down.
     cancel_error_ = batch->payload->cancel_stream.cancel_error;
     GRPC_TRACE_LOG(client_channel_lb_call, INFO)
-        << "chand=" << chand() << " lb_call=" << this
+        << "chand=" << chand_ << " lb_call=" << this
         << ": recording cancel_error=" << StatusToString(cancel_error_).c_str();
     // Fail all pending batches.
-    PendingBatchesFail(cancel_error_, NoYieldCallCombiner);
+    buffered_call_.Fail(cancel_error_, BufferedCall::NoYieldCallCombiner);
     // Note: This will release the call combiner.
     grpc_transport_stream_op_batch_finish_with_failure(batch, cancel_error_,
                                                        call_combiner_);
     return;
   }
   // Add the batch to the pending list.
-  PendingBatchesAdd(batch);
+  buffered_call_.EnqueueBatch(batch);
   // For batches containing a send_initial_metadata op, acquire the
   // channel's LB mutex to pick a subchannel.
   if (GPR_LIKELY(batch->send_initial_metadata)) {
@@ -2858,22 +2643,22 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
   } else {
     // For all other batches, release the call combiner.
     GRPC_TRACE_LOG(client_channel_lb_call, INFO)
-        << "chand=" << chand() << " lb_call=" << this
+        << "chand=" << chand_ << " lb_call=" << this
         << ": saved batch, yielding call combiner";
     GRPC_CALL_COMBINER_STOP(call_combiner_,
                             "batch does not include send_initial_metadata");
   }
 }
 
-void ClientChannelFilter::FilterBasedLoadBalancedCall::RecvInitialMetadataReady(
+void ClientChannelFilter::LoadBalancedCall::RecvInitialMetadataReady(
     void* arg, grpc_error_handle error) {
-  auto* self = static_cast<FilterBasedLoadBalancedCall*>(arg);
+  auto* self = static_cast<LoadBalancedCall*>(arg);
   GRPC_TRACE_LOG(client_channel_lb_call, INFO)
-      << "chand=" << self->chand() << " lb_call=" << self
+      << "chand=" << self->chand_ << " lb_call=" << self
       << ": got recv_initial_metadata_ready: error=" << StatusToString(error);
   if (error.ok()) {
     // recv_initial_metadata_flags is not populated for clients
-    self->call_attempt_tracer()->RecordReceivedInitialMetadata(
+    self->call_attempt_tracer_->RecordReceivedInitialMetadata(
         self->recv_initial_metadata_);
     auto* peer_string = self->recv_initial_metadata_->get_pointer(PeerString());
     if (peer_string != nullptr) self->peer_string_ = peer_string->Ref();
@@ -2882,27 +2667,28 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::RecvInitialMetadataReady(
                error);
 }
 
-void ClientChannelFilter::FilterBasedLoadBalancedCall::
-    RecvTrailingMetadataReady(void* arg, grpc_error_handle error) {
-  auto* self = static_cast<FilterBasedLoadBalancedCall*>(arg);
+void ClientChannelFilter::LoadBalancedCall::RecvTrailingMetadataReady(
+    void* arg, grpc_error_handle error) {
+  auto* self = static_cast<LoadBalancedCall*>(arg);
   GRPC_TRACE_LOG(client_channel_lb_call, INFO)
-      << "chand=" << self->chand() << " lb_call=" << self
+      << "chand=" << self->chand_ << " lb_call=" << self
       << ": got recv_trailing_metadata_ready: error=" << StatusToString(error)
-      << " call_attempt_tracer()=" << self->call_attempt_tracer()
-      << " lb_subchannel_call_tracker_=" << self->lb_subchannel_call_tracker()
+      << " call_attempt_tracer_=" << self->call_attempt_tracer_
+      << " lb_subchannel_call_tracker_="
+      << self->lb_subchannel_call_tracker_.get()
       << " failure_error_=" << StatusToString(self->failure_error_);
   // Check if we have a tracer or an LB callback to invoke.
-  if (self->call_attempt_tracer() != nullptr ||
-      self->lb_subchannel_call_tracker() != nullptr) {
+  if (self->call_attempt_tracer_ != nullptr ||
+      self->lb_subchannel_call_tracker_ != nullptr) {
     // Get the call's status.
     absl::Status status;
     if (!error.ok()) {
       // Get status from error.
       grpc_status_code code;
       std::string message;
-      grpc_error_get_status(
-          error, self->arena()->GetContext<Call>()->deadline(), &code, &message,
-          /*http_error=*/nullptr, /*error_string=*/nullptr);
+      grpc_error_get_status(error, self->arena_->GetContext<Call>()->deadline(),
+                            &code, &message,
+                            /*http_error=*/nullptr, /*error_string=*/nullptr);
       status = absl::Status(static_cast<absl::StatusCode>(code), message);
     } else {
       // Get status from headers.
@@ -2933,78 +2719,18 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
                error);
 }
 
-// A class to handle the call combiner cancellation callback for a
-// queued pick.
-// TODO(roth): When we implement hedging support, we won't be able to
-// register a call combiner cancellation closure for each LB pick,
-// because there may be multiple LB picks happening in parallel.
-// Instead, we will probably need to maintain a list in the CallData
-// object of pending LB picks to be cancelled when the closure runs.
-class ClientChannelFilter::FilterBasedLoadBalancedCall::LbQueuedCallCanceller
-    final {
- public:
-  explicit LbQueuedCallCanceller(
-      RefCountedPtr<FilterBasedLoadBalancedCall> lb_call)
-      : lb_call_(std::move(lb_call)) {
-    GRPC_CALL_STACK_REF(lb_call_->owning_call_, "LbQueuedCallCanceller");
-    GRPC_CLOSURE_INIT(&closure_, &CancelLocked, this, nullptr);
-    lb_call_->call_combiner_->SetNotifyOnCancel(&closure_);
-  }
-
- private:
-  static void CancelLocked(void* arg, grpc_error_handle error) {
-    auto* self = static_cast<LbQueuedCallCanceller*>(arg);
-    auto* lb_call = self->lb_call_.get();
-    auto* chand = lb_call->chand();
-    {
-      MutexLock lock(&chand->lb_mu_);
-      GRPC_TRACE_LOG(client_channel_lb_call, INFO)
-          << "chand=" << chand << " lb_call=" << lb_call
-          << ": cancelling queued pick: error=" << StatusToString(error)
-          << " self=" << self
-          << " calld->pick_canceller=" << lb_call->lb_call_canceller_;
-      if (lb_call->lb_call_canceller_ == self && !error.ok()) {
-        lb_call->Commit();
-        // Remove pick from list of queued picks.
-        lb_call->RemoveCallFromLbQueuedCallsLocked();
-        // Remove from queued picks list.
-        chand->lb_queued_calls_.erase(self->lb_call_);
-        // Fail pending batches on the call.
-        lb_call->PendingBatchesFail(error,
-                                    YieldCallCombinerIfPendingBatchesFound);
-      }
-    }
-    // Unref lb_call before unreffing the call stack, since unreffing
-    // the call stack may destroy the arena in which lb_call is allocated.
-    auto* owning_call = lb_call->owning_call_;
-    self->lb_call_.reset();
-    GRPC_CALL_STACK_UNREF(owning_call, "LbQueuedCallCanceller");
-    delete self;
-  }
-
-  RefCountedPtr<FilterBasedLoadBalancedCall> lb_call_;
-  grpc_closure closure_;
-};
-
-void ClientChannelFilter::FilterBasedLoadBalancedCall::TryPick(
-    bool was_queued) {
+void ClientChannelFilter::LoadBalancedCall::TryPick(bool was_queued) {
   auto result = PickSubchannel(was_queued);
   if (result.has_value()) {
     if (!result->ok()) {
-      PendingBatchesFail(*result, YieldCallCombiner);
+      buffered_call_.Fail(*result, BufferedCall::YieldCallCombiner);
       return;
     }
     CreateSubchannelCall();
   }
 }
 
-void ClientChannelFilter::FilterBasedLoadBalancedCall::OnAddToQueueLocked() {
-  // Register call combiner cancellation callback.
-  lb_call_canceller_ =
-      new LbQueuedCallCanceller(RefAsSubclass<FilterBasedLoadBalancedCall>());
-}
-
-void ClientChannelFilter::FilterBasedLoadBalancedCall::RetryPickLocked() {
+void ClientChannelFilter::LoadBalancedCall::RetryPickLocked() {
   // Lame the call combiner canceller.
   lb_call_canceller_ = nullptr;
   // Do an async callback to resume call processing, so that we're not
@@ -3033,17 +2759,17 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::RetryPickLocked() {
                absl::OkStatus());
 }
 
-void ClientChannelFilter::FilterBasedLoadBalancedCall::CreateSubchannelCall() {
+void ClientChannelFilter::LoadBalancedCall::CreateSubchannelCall() {
   SubchannelCall::Args call_args = {
-      connected_subchannel()->Ref(), pollent_, /*start_time=*/0,
-      arena()->GetContext<Call>()->deadline(),
+      connected_subchannel_->Ref(), pollent_, /*start_time=*/0,
+      arena_->GetContext<Call>()->deadline(),
       // TODO(roth): When we implement hedging support, we will probably
       // need to use a separate call arena for each subchannel call.
-      arena(), call_combiner_};
+      arena_, call_combiner_};
   grpc_error_handle error;
   subchannel_call_ = SubchannelCall::Create(std::move(call_args), &error);
   GRPC_TRACE_LOG(client_channel_lb_call, INFO)
-      << "chand=" << chand() << " lb_call=" << this
+      << "chand=" << chand_ << " lb_call=" << this
       << ": create subchannel_call=" << subchannel_call_.get()
       << ": error=" << StatusToString(error);
   if (on_call_destruction_complete_ != nullptr) {
@@ -3051,9 +2777,13 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::CreateSubchannelCall() {
     on_call_destruction_complete_ = nullptr;
   }
   if (GPR_UNLIKELY(!error.ok())) {
-    PendingBatchesFail(error, YieldCallCombiner);
+    buffered_call_.Fail(error, BufferedCall::YieldCallCombiner);
   } else {
-    PendingBatchesResume();
+    buffered_call_.Resume([subchannel_call = subchannel_call_](
+                              grpc_transport_stream_op_batch* batch) {
+      // Note: This will release the call combiner.
+      subchannel_call->StartTransportStreamOpBatch(batch);
+    });
   }
 }