grpc 1.62.0 → 1.64.0

data/src/core/client_channel/client_channel_filter.cc

@@ -30,6 +30,7 @@
 #include <vector>
 
 #include "absl/cleanup/cleanup.h"
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/cord.h"
@@ -49,9 +50,8 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
 
-#include "src/core/client_channel/backend_metric.h"
+#include "src/core/channelz/channel_trace.h"
 #include "src/core/client_channel/backup_poller.h"
-#include "src/core/client_channel/client_channel_channelz.h"
 #include "src/core/client_channel/client_channel_internal.h"
 #include "src/core/client_channel/client_channel_service_config.h"
 #include "src/core/client_channel/config_selector.h"
@@ -61,10 +61,9 @@
 #include "src/core/client_channel/retry_filter.h"
 #include "src/core/client_channel/subchannel.h"
 #include "src/core/client_channel/subchannel_interface_internal.h"
-#include "src/core/ext/filters/deadline/deadline_filter.h"
+#include "src/core/handshaker/proxy_mapper_registry.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/channel_trace.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
@@ -77,7 +76,6 @@
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/unique_type_name.h"
 #include "src/core/lib/gprpp/work_serializer.h"
-#include "src/core/lib/handshaker/proxy_mapper_registry.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/pollset_set.h"
@@ -92,20 +90,20 @@
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/promise/try_seq.h"
 #include "src/core/lib/security/credentials/credentials.h"
-#include "src/core/service_config/service_config_call_data.h"
-#include "src/core/service_config/service_config_impl.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/call.h"
-#include "src/core/lib/surface/channel.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/load_balancing/backend_metric_parser.h"
 #include "src/core/load_balancing/child_policy_handler.h"
 #include "src/core/load_balancing/lb_policy_registry.h"
 #include "src/core/load_balancing/subchannel_interface.h"
 #include "src/core/resolver/endpoint_addresses.h"
 #include "src/core/resolver/resolver_registry.h"
+#include "src/core/service_config/service_config_call_data.h"
+#include "src/core/service_config/service_config_impl.h"
 
 //
 // Client channel filter
@@ -192,7 +190,7 @@ class ClientChannelFilter::CallData {
   RefCountedPtr<DynamicFilters> dynamic_filters_;
 };
 
-class ClientChannelFilter::FilterBasedCallData
+class ClientChannelFilter::FilterBasedCallData final
     : public ClientChannelFilter::CallData {
  public:
   static grpc_error_handle Init(grpc_call_element* elem,
@@ -211,14 +209,14 @@ class ClientChannelFilter::FilterBasedCallData
                       const grpc_call_element_args& args);
   ~FilterBasedCallData() override;
 
-  grpc_call_element* elem() const { return deadline_state_.elem; }
-  grpc_call_stack* owning_call() const { return deadline_state_.call_stack; }
-  CallCombiner* call_combiner() const { return deadline_state_.call_combiner; }
+  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 deadline_state_.arena; }
+  Arena* arena() const override { return arena_; }
   grpc_polling_entity* pollent() override { return pollent_; }
   grpc_metadata_batch* send_initial_metadata() override {
     return pending_batches_[0]
@@ -271,10 +269,8 @@ class ClientChannelFilter::FilterBasedCallData
   void ResetDeadline(Duration timeout) override {
     const Timestamp per_method_deadline =
         Timestamp::FromCycleCounterRoundUp(call_start_time_) + timeout;
-    if (per_method_deadline < deadline_) {
-      deadline_ = per_method_deadline;
-      grpc_deadline_state_reset(&deadline_state_, deadline_);
-    }
+    static_cast<Call*>(call_context_[GRPC_CONTEXT_CALL].value)
+        ->UpdateDeadline(per_method_deadline);
   }
 
   void CreateDynamicCall();
@@ -287,8 +283,10 @@ class ClientChannelFilter::FilterBasedCallData
   gpr_cycle_counter call_start_time_;
   Timestamp deadline_;
 
-  // State for handling deadlines.
-  grpc_deadline_state deadline_state_;
+  Arena* const arena_;
+  grpc_call_element* const elem_;
+  grpc_call_stack* const owning_call_;
+  CallCombiner* const call_combiner_;
 
   grpc_polling_entity* pollent_ = nullptr;
 
@@ -312,7 +310,7 @@ class ClientChannelFilter::FilterBasedCallData
   grpc_error_handle cancel_error_;
 };
 
-class ClientChannelFilter::PromiseBasedCallData
+class ClientChannelFilter::PromiseBasedCallData final
     : public ClientChannelFilter::CallData {
  public:
   explicit PromiseBasedCallData(ClientChannelFilter* chand) : chand_(chand) {}
@@ -388,11 +386,12 @@ class ClientChannelFilter::PromiseBasedCallData
   }
 
   void ResetDeadline(Duration timeout) override {
+    Call* call = GetContext<Call>();
     CallContext* call_context = GetContext<CallContext>();
     const Timestamp per_method_deadline =
         Timestamp::FromCycleCounterRoundUp(call_context->call_start_time()) +
         timeout;
-    call_context->UpdateDeadline(per_method_deadline);
+    call->UpdateDeadline(per_method_deadline);
   }
 
   ClientChannelFilter* chand_;
@@ -452,7 +451,7 @@ ClientChannelServiceConfigCallData* GetServiceConfigCallData(
       context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value);
 }
 
-class DynamicTerminationFilter {
+class DynamicTerminationFilter final {
  public:
   class CallData;
 
@@ -460,8 +459,8 @@ class DynamicTerminationFilter {
 
   static grpc_error_handle Init(grpc_channel_element* elem,
                                 grpc_channel_element_args* args) {
-    GPR_ASSERT(args->is_last);
-    GPR_ASSERT(elem->filter == &kFilterVtable);
+    CHECK(args->is_last);
+    CHECK(elem->filter == &kFilterVtable);
     new (elem->channel_data) DynamicTerminationFilter(args->channel_args);
     return absl::OkStatus();
   }
@@ -497,7 +496,7 @@ class DynamicTerminationFilter {
   ClientChannelFilter* chand_;
 };
 
-class DynamicTerminationFilter::CallData {
+class DynamicTerminationFilter::CallData final {
  public:
   static grpc_error_handle Init(grpc_call_element* elem,
                                 const grpc_call_element_args* args) {
@@ -594,7 +593,7 @@ const grpc_channel_filter DynamicTerminationFilter::kFilterVtable = {
 // ClientChannelFilter::ResolverResultHandler
 //
 
-class ClientChannelFilter::ResolverResultHandler
+class ClientChannelFilter::ResolverResultHandler final
     : public Resolver::ResultHandler {
  public:
   explicit ResolverResultHandler(ClientChannelFilter* chand) : chand_(chand) {
@@ -629,7 +628,8 @@ class ClientChannelFilter::ResolverResultHandler
 // underlying subchannel is shared between channels, this wrapper will only
 // be used within one channel, so it will always be synchronized by the
 // control plane work_serializer.
-class ClientChannelFilter::SubchannelWrapper : public SubchannelInterface {
+class ClientChannelFilter::SubchannelWrapper final
+    : public SubchannelInterface {
  public:
   SubchannelWrapper(ClientChannelFilter* chand,
                     RefCountedPtr<Subchannel> subchannel)
@@ -644,7 +644,9 @@ class ClientChannelFilter::SubchannelWrapper : public SubchannelInterface {
               chand, this, subchannel_.get());
     }
     GRPC_CHANNEL_STACK_REF(chand_->owning_stack_, "SubchannelWrapper");
-    GPR_DEBUG_ASSERT(chand_->work_serializer_->RunningInWorkSerializer());
+#ifndef NDEBUG
+    DCHECK(chand_->work_serializer_->RunningInWorkSerializer());
+#endif
     if (chand_->channelz_node_ != nullptr) {
       auto* subchannel_node = subchannel_->channelz_node();
       if (subchannel_node != nullptr) {
@@ -672,7 +674,7 @@ class ClientChannelFilter::SubchannelWrapper : public SubchannelInterface {
         auto* subchannel_node = subchannel_->channelz_node();
         if (subchannel_node != nullptr) {
           auto it = chand_->subchannel_refcount_map_.find(subchannel_.get());
-          GPR_ASSERT(it != chand_->subchannel_refcount_map_.end());
+          CHECK(it != chand_->subchannel_refcount_map_.end());
           --it->second;
           if (it->second == 0) {
             chand_->channelz_node_->RemoveChildSubchannel(
@@ -685,7 +687,7 @@ class ClientChannelFilter::SubchannelWrapper : public SubchannelInterface {
     GRPC_CHANNEL_STACK_UNREF(chand_->owning_stack_, "SubchannelWrapper");
   }
 
-  void Orphan() override {
+  void Orphaned() override {
     if (!IsWorkSerializerDispatchEnabled()) return;
     // Make sure we clean up the channel's subchannel maps inside the
     // WorkSerializer.
@@ -699,7 +701,7 @@ class ClientChannelFilter::SubchannelWrapper : public SubchannelInterface {
             if (subchannel_node != nullptr) {
               auto it =
                   chand_->subchannel_refcount_map_.find(subchannel_.get());
-              GPR_ASSERT(it != chand_->subchannel_refcount_map_.end());
+              CHECK(it != chand_->subchannel_refcount_map_.end());
               --it->second;
               if (it->second == 0) {
                 chand_->channelz_node_->RemoveChildSubchannel(
@@ -717,7 +719,7 @@ class ClientChannelFilter::SubchannelWrapper : public SubchannelInterface {
       std::unique_ptr<ConnectivityStateWatcherInterface> watcher) override
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     auto& watcher_wrapper = watcher_map_[watcher.get()];
-    GPR_ASSERT(watcher_wrapper == nullptr);
+    CHECK_EQ(watcher_wrapper, nullptr);
     watcher_wrapper = new WatcherWrapper(
         std::move(watcher),
         RefAsSubclass<SubchannelWrapper>(DEBUG_LOCATION, "WatcherWrapper"));
@@ -729,7 +731,7 @@ class ClientChannelFilter::SubchannelWrapper : public SubchannelInterface {
   void CancelConnectivityStateWatch(ConnectivityStateWatcherInterface* watcher)
       override ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     auto it = watcher_map_.find(watcher);
-    GPR_ASSERT(it != watcher_map_.end());
+    CHECK(it != watcher_map_.end());
     subchannel_->CancelConnectivityStateWatch(it->second);
     watcher_map_.erase(it);
   }
@@ -746,7 +748,7 @@ class ClientChannelFilter::SubchannelWrapper : public SubchannelInterface {
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     static_cast<InternalSubchannelDataWatcherInterface*>(watcher.get())
         ->SetSubchannel(subchannel_.get());
-    GPR_ASSERT(data_watchers_.insert(std::move(watcher)).second);
+    CHECK(data_watchers_.insert(std::move(watcher)).second);
   }
 
   void CancelDataWatcher(DataWatcherInterface* watcher) override
@@ -772,7 +774,8 @@ class ClientChannelFilter::SubchannelWrapper : public SubchannelInterface {
   // This class handles things like hopping into the WorkSerializer
   // before passing notifications to the LB policy and propagating
   // keepalive information betwen subchannels.
-  class WatcherWrapper : public Subchannel::ConnectivityStateWatcherInterface {
+  class WatcherWrapper final
+      : public Subchannel::ConnectivityStateWatcherInterface {
    public:
     WatcherWrapper(
         std::unique_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
@@ -921,7 +924,7 @@ ClientChannelFilter::ExternalConnectivityWatcher::ExternalConnectivityWatcher(
   {
     MutexLock lock(&chand_->external_watchers_mu_);
     // Will be deleted when the watch is complete.
-    GPR_ASSERT(chand->external_watchers_[on_complete] == nullptr);
+    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>(
@@ -1025,7 +1028,7 @@ void ClientChannelFilter::ExternalConnectivityWatcher::RemoveWatcherLocked() {
 // ClientChannelFilter::ConnectivityWatcherAdder
 //
 
-class ClientChannelFilter::ConnectivityWatcherAdder {
+class ClientChannelFilter::ConnectivityWatcherAdder final {
  public:
   ConnectivityWatcherAdder(
       ClientChannelFilter* chand, grpc_connectivity_state initial_state,
@@ -1058,7 +1061,7 @@ class ClientChannelFilter::ConnectivityWatcherAdder {
 // ClientChannelFilter::ConnectivityWatcherRemover
 //
 
-class ClientChannelFilter::ConnectivityWatcherRemover {
+class ClientChannelFilter::ConnectivityWatcherRemover final {
  public:
   ConnectivityWatcherRemover(ClientChannelFilter* chand,
                              AsyncConnectivityStateWatcherInterface* watcher)
@@ -1088,7 +1091,7 @@ class ClientChannelFilter::ConnectivityWatcherRemover {
 // ClientChannelFilter::ClientChannelControlHelper
 //
 
-class ClientChannelFilter::ClientChannelControlHelper
+class ClientChannelFilter::ClientChannelControlHelper final
     : public LoadBalancingPolicy::ChannelControlHelper {
  public:
   explicit ClientChannelControlHelper(ClientChannelFilter* chand)
@@ -1148,6 +1151,8 @@ class ClientChannelFilter::ClientChannelControlHelper
     chand_->resolver_->RequestReresolutionLocked();
   }
 
+  absl::string_view GetTarget() override { return chand_->target_uri_; }
+
   absl::string_view GetAuthority() override {
     return chand_->default_authority_;
   }
@@ -1166,6 +1171,10 @@ class ClientChannelFilter::ClientChannelControlHelper
     return chand_->owning_stack_->EventEngine();
   }
 
+  GlobalStatsPluginRegistry::StatsPluginGroup& GetStatsPluginGroup() override {
+    return *chand_->owning_stack_->stats_plugin_group;
+  }
+
   void AddTraceEvent(TraceSeverity severity, absl::string_view message) override
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     if (chand_->resolver_ == nullptr) return;  // Shutting down.
@@ -1191,21 +1200,11 @@ class ClientChannelFilter::ClientChannelControlHelper
 // ClientChannelFilter implementation
 //
 
-ClientChannelFilter* ClientChannelFilter::GetFromChannel(Channel* channel) {
-  grpc_channel_element* elem =
-      grpc_channel_stack_last_element(channel->channel_stack());
-  if (elem->filter != &kFilterVtableWithPromises &&
-      elem->filter != &kFilterVtableWithoutPromises) {
-    return nullptr;
-  }
-  return static_cast<ClientChannelFilter*>(elem->channel_data);
-}
-
 grpc_error_handle ClientChannelFilter::Init(grpc_channel_element* elem,
                                             grpc_channel_element_args* args) {
-  GPR_ASSERT(args->is_last);
-  GPR_ASSERT(elem->filter == &kFilterVtableWithPromises ||
-             elem->filter == &kFilterVtableWithoutPromises);
+  CHECK(args->is_last);
+  CHECK(elem->filter == &kFilterVtableWithPromises ||
+        elem->filter == &kFilterVtableWithoutPromises);
   grpc_error_handle error;
   new (elem->channel_data) ClientChannelFilter(args, &error);
   return error;
@@ -1231,9 +1230,6 @@ RefCountedPtr<SubchannelPoolInterface> GetSubchannelPool(
 ClientChannelFilter::ClientChannelFilter(grpc_channel_element_args* args,
                                          grpc_error_handle* error)
     : channel_args_(args->channel_args),
-      deadline_checking_enabled_(
-          channel_args_.GetBool(GRPC_ARG_ENABLE_DEADLINE_CHECKS)
-              .value_or(!channel_args_.WantMinimalStack())),
       owning_stack_(args->channel_stack),
       client_channel_factory_(channel_args_.GetObject<ClientChannelFactory>()),
       channelz_node_(channel_args_.GetObject<channelz::ChannelNode>()),
@@ -1270,18 +1266,19 @@ ClientChannelFilter::ClientChannelFilter(grpc_channel_element_args* args,
   }
   default_service_config_ = std::move(*service_config);
   // Get URI to resolve, using proxy mapper if needed.
-  absl::optional<std::string> server_uri =
+  absl::optional<std::string> target_uri =
       channel_args_.GetOwnedString(GRPC_ARG_SERVER_URI);
-  if (!server_uri.has_value()) {
+  if (!target_uri.has_value()) {
     *error = GRPC_ERROR_CREATE(
         "target URI channel arg missing or wrong type in client channel "
         "filter");
     return;
   }
+  target_uri_ = std::move(*target_uri);
   uri_to_resolve_ = CoreConfiguration::Get()
                         .proxy_mapper_registry()
-                        .MapName(*server_uri, &channel_args_)
-                        .value_or(*server_uri);
+                        .MapName(target_uri_, &channel_args_)
+                        .value_or(target_uri_);
   // Make sure the URI to resolve is valid, so that we know that
   // resolver creation will succeed later.
   if (!CoreConfiguration::Get().resolver_registry().IsValidTarget(
@@ -1306,7 +1303,7 @@ ClientChannelFilter::ClientChannelFilter(grpc_channel_element_args* args,
   if (!default_authority.has_value()) {
     default_authority_ =
         CoreConfiguration::Get().resolver_registry().GetDefaultAuthority(
-            *server_uri);
+            target_uri_);
   } else {
     default_authority_ = std::move(*default_authority);
   }
@@ -1344,6 +1341,7 @@ 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,
@@ -1449,7 +1447,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
-  GPR_ASSERT(lb_policy_config.ok());
+  CHECK(lb_policy_config.ok());
   return std::move(*lb_policy_config);
 }
 
@@ -1729,7 +1727,7 @@ void ClientChannelFilter::UpdateServiceConfigInDataPlaneLocked() {
   }
   RefCountedPtr<DynamicFilters> dynamic_filters =
       DynamicFilters::Create(new_args, std::move(filters));
-  GPR_ASSERT(dynamic_filters != nullptr);
+  CHECK(dynamic_filters != nullptr);
   // Grab data plane lock to update service config.
   //
   // We defer unreffing the old values (and deallocating memory) until
@@ -1760,7 +1758,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.
-  GPR_ASSERT(resolver_ != nullptr);
+  CHECK(resolver_ != nullptr);
   UpdateStateLocked(GRPC_CHANNEL_CONNECTING, absl::Status(),
                     "started resolving");
   resolver_->StartLocked();
@@ -1869,7 +1867,7 @@ T HandlePickResult(
   }
   auto* drop_pick =
       absl::get_if<LoadBalancingPolicy::PickResult::Drop>(&result->result);
-  GPR_ASSERT(drop_pick != nullptr);
+  CHECK_NE(drop_pick, nullptr);
   return drop_func(drop_pick);
 }
 
@@ -1963,7 +1961,7 @@ void ClientChannelFilter::StartTransportOpLocked(grpc_transport_op* op) {
       }
     } else {
       // Disconnect.
-      GPR_ASSERT(disconnect_error_.ok());
+      CHECK(disconnect_error_.ok());
       disconnect_error_ = op->disconnect_with_error;
       UpdateStateAndPickerLocked(
           GRPC_CHANNEL_SHUTDOWN, absl::Status(), "shutdown from API",
@@ -1981,7 +1979,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);
-  GPR_ASSERT(op->set_accept_stream == false);
+  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);
@@ -2111,8 +2109,7 @@ grpc_error_handle ClientChannelFilter::CallData::ApplyServiceConfigToCallLocked(
   if (method_params != nullptr) {
     // If the deadline from the service config is shorter than the one
     // from the client API, reset the deadline timer.
-    if (chand()->deadline_checking_enabled_ &&
-        method_params->timeout() != Duration::Zero()) {
+    if (method_params->timeout() != Duration::Zero()) {
       ResetDeadline(method_params->timeout());
     }
     // If the service config set wait_for_ready and the application
@@ -2212,12 +2209,10 @@ ClientChannelFilter::FilterBasedCallData::FilterBasedCallData(
       call_context_(args.context),
       call_start_time_(args.start_time),
       deadline_(args.deadline),
-      deadline_state_(
-          elem, args,
-          GPR_LIKELY(static_cast<ClientChannelFilter*>(elem->channel_data)
-                         ->deadline_checking_enabled_)
-              ? args.deadline
-              : Timestamp::InfFuture()) {
+      arena_(args.arena),
+      elem_(elem),
+      owning_call_(args.call_stack),
+      call_combiner_(args.call_combiner) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
     gpr_log(GPR_INFO, "chand=%p calld=%p: created call", chand(), this);
   }
@@ -2227,7 +2222,7 @@ ClientChannelFilter::FilterBasedCallData::~FilterBasedCallData() {
   CSliceUnref(path_);
   // Make sure there are no remaining pending batches.
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-    GPR_ASSERT(pending_batches_[i] == nullptr);
+    CHECK_EQ(pending_batches_[i], nullptr);
   }
 }
 
@@ -2261,10 +2256,6 @@ void ClientChannelFilter::FilterBasedCallData::StartTransportStreamOpBatch(
     gpr_log(GPR_INFO, "chand=%p calld=%p: batch started from above: %s", chand,
             calld, grpc_transport_stream_op_batch_string(batch, false).c_str());
   }
-  if (GPR_LIKELY(chand->deadline_checking_enabled_)) {
-    grpc_deadline_state_client_start_transport_stream_op_batch(
-        &calld->deadline_state_, batch);
-  }
   // Intercept recv_trailing_metadata to commit the call, in case we wind up
   // failing the call before we get down to the retry or LB call layer.
   if (batch->recv_trailing_metadata) {
@@ -2389,7 +2380,7 @@ void ClientChannelFilter::FilterBasedCallData::PendingBatchesAdd(
             chand(), this, idx);
   }
   grpc_transport_stream_op_batch*& pending = pending_batches_[idx];
-  GPR_ASSERT(pending == nullptr);
+  CHECK_EQ(pending, nullptr);
   pending = batch;
 }
 
@@ -2409,7 +2400,7 @@ void ClientChannelFilter::FilterBasedCallData::FailPendingBatchInCallCombiner(
 void ClientChannelFilter::FilterBasedCallData::PendingBatchesFail(
     grpc_error_handle error,
     YieldCallCombinerPredicate yield_call_combiner_predicate) {
-  GPR_ASSERT(!error.ok());
+  CHECK(!error.ok());
   if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace)) {
     size_t num_batches = 0;
     for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
@@ -2481,7 +2472,8 @@ void ClientChannelFilter::FilterBasedCallData::PendingBatchesResume() {
 
 // A class to handle the call combiner cancellation callback for a
 // queued pick.
-class ClientChannelFilter::FilterBasedCallData::ResolverQueuedCallCanceller {
+class ClientChannelFilter::FilterBasedCallData::ResolverQueuedCallCanceller
+    final {
  public:
   explicit ResolverQueuedCallCanceller(FilterBasedCallData* calld)
       : calld_(calld) {
@@ -2602,7 +2594,7 @@ void ClientChannelFilter::FilterBasedCallData::
 // ClientChannelFilter::LoadBalancedCall::LbCallState
 //
 
-class ClientChannelFilter::LoadBalancedCall::LbCallState
+class ClientChannelFilter::LoadBalancedCall::LbCallState final
     : public ClientChannelLbCallState {
  public:
   explicit LbCallState(LoadBalancedCall* lb_call) : lb_call_(lb_call) {}
@@ -2624,7 +2616,7 @@ class ClientChannelFilter::LoadBalancedCall::LbCallState
 // ClientChannelFilter::LoadBalancedCall::Metadata
 //
 
-class ClientChannelFilter::LoadBalancedCall::Metadata
+class ClientChannelFilter::LoadBalancedCall::Metadata final
     : public LoadBalancingPolicy::MetadataInterface {
  public:
   explicit Metadata(grpc_metadata_batch* batch) : batch_(batch) {}
@@ -2664,7 +2656,7 @@ class ClientChannelFilter::LoadBalancedCall::Metadata
   }
 
  private:
-  class Encoder {
+  class Encoder final {
    public:
     void Encode(const Slice& key, const Slice& value) {
       out_.emplace_back(std::string(key.as_string_view()),
@@ -2717,7 +2709,7 @@ ClientChannelFilter::LoadBalancedCall::LbCallState::GetCallAttemptTracer()
 // ClientChannelFilter::LoadBalancedCall::BackendMetricAccessor
 //
 
-class ClientChannelFilter::LoadBalancedCall::BackendMetricAccessor
+class ClientChannelFilter::LoadBalancedCall::BackendMetricAccessor final
     : public LoadBalancingPolicy::BackendMetricAccessor {
  public:
   BackendMetricAccessor(LoadBalancedCall* lb_call,
@@ -2738,7 +2730,7 @@ class ClientChannelFilter::LoadBalancedCall::BackendMetricAccessor
   }
 
  private:
-  class BackendMetricAllocator : public BackendMetricAllocatorInterface {
+  class BackendMetricAllocator final : public BackendMetricAllocatorInterface {
    public:
     explicit BackendMetricAllocator(Arena* arena) : arena_(arena) {}
 
@@ -2898,6 +2890,15 @@ ClientChannelFilter::LoadBalancedCall::PickSubchannel(bool was_queued) {
     set_picker(chand_->picker_);
   }
   while (true) {
+    // TODO(roth): Fix race condition in channel_idle filter and any
+    // other possible causes of this.
+    if (pickers.back() == nullptr) {
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
+        gpr_log(GPR_ERROR, "chand=%p lb_call=%p: picker is null, failing call",
+                chand_, this);
+      }
+      return absl::InternalError("picker is null -- shouldn't happen");
+    }
     // Do pick.
     if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
       gpr_log(GPR_INFO, "chand=%p lb_call=%p: performing pick with picker=%p",
@@ -2948,11 +2949,11 @@ ClientChannelFilter::LoadBalancedCall::PickSubchannel(bool was_queued) {
 
 bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
     LoadBalancingPolicy::SubchannelPicker* picker, grpc_error_handle* error) {
-  GPR_ASSERT(connected_subchannel_ == nullptr);
+  CHECK(connected_subchannel_ == nullptr);
   // Perform LB pick.
   LoadBalancingPolicy::PickArgs pick_args;
   Slice* path = send_initial_metadata()->get_pointer(HttpPathMetadata());
-  GPR_ASSERT(path != nullptr);
+  CHECK_NE(path, nullptr);
   pick_args.path = path->as_string_view();
   LbCallState lb_call_state(this);
   pick_args.call_state = &lb_call_state;
@@ -2968,7 +2969,7 @@ bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
                   "chand=%p lb_call=%p: LB pick succeeded: subchannel=%p",
                   chand_, this, complete_pick->subchannel.get());
         }
-        GPR_ASSERT(complete_pick->subchannel != nullptr);
+        CHECK(complete_pick->subchannel != nullptr);
         // Grab a ref to the connected subchannel while we're still
         // holding the data plane mutex.
         SubchannelWrapper* subchannel =
@@ -3045,7 +3046,6 @@ ClientChannelFilter::FilterBasedLoadBalancedCall::FilterBasedLoadBalancedCall(
     absl::AnyInvocable<void()> on_commit, bool is_transparent_retry)
     : LoadBalancedCall(chand, args.context, std::move(on_commit),
                        is_transparent_retry),
-      deadline_(args.deadline),
       arena_(args.arena),
       owning_call_(args.call_stack),
       call_combiner_(args.call_combiner),
@@ -3056,7 +3056,7 @@ ClientChannelFilter::FilterBasedLoadBalancedCall::
     ~FilterBasedLoadBalancedCall() {
   // Make sure there are no remaining pending batches.
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
-    GPR_ASSERT(pending_batches_[i] == nullptr);
+    CHECK_EQ(pending_batches_[i], nullptr);
   }
   if (on_call_destruction_complete_ != nullptr) {
     ExecCtx::Run(DEBUG_LOCATION, on_call_destruction_complete_,
@@ -3099,7 +3099,7 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::PendingBatchesAdd(
             "chand=%p lb_call=%p: adding pending batch at index %" PRIuPTR,
             chand(), this, idx);
   }
-  GPR_ASSERT(pending_batches_[idx] == nullptr);
+  CHECK_EQ(pending_batches_[idx], nullptr);
   pending_batches_[idx] = batch;
 }
 
@@ -3119,7 +3119,7 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
 void ClientChannelFilter::FilterBasedLoadBalancedCall::PendingBatchesFail(
     grpc_error_handle error,
     YieldCallCombinerPredicate yield_call_combiner_predicate) {
-  GPR_ASSERT(!error.ok());
+  CHECK(!error.ok());
   failure_error_ = error;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
     size_t num_batches = 0;
@@ -3345,8 +3345,12 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
       // Get status from error.
       grpc_status_code code;
       std::string message;
-      grpc_error_get_status(error, self->deadline_, &code, &message,
-                            /*http_error=*/nullptr, /*error_string=*/nullptr);
+      grpc_error_get_status(
+          error,
+          static_cast<Call*>(self->call_context()[GRPC_CONTEXT_CALL].value)
+              ->deadline(),
+          &code, &message,
+          /*http_error=*/nullptr, /*error_string=*/nullptr);
       status = absl::Status(static_cast<absl::StatusCode>(code), message);
     } else {
       // Get status from headers.
@@ -3384,7 +3388,8 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
 // 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 {
+class ClientChannelFilter::FilterBasedLoadBalancedCall::LbQueuedCallCanceller
+    final {
  public:
   explicit LbQueuedCallCanceller(
       RefCountedPtr<FilterBasedLoadBalancedCall> lb_call)
@@ -3480,10 +3485,11 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::RetryPickLocked() {
 
 void ClientChannelFilter::FilterBasedLoadBalancedCall::CreateSubchannelCall() {
   Slice* path = send_initial_metadata()->get_pointer(HttpPathMetadata());
-  GPR_ASSERT(path != nullptr);
+  CHECK_NE(path, nullptr);
   SubchannelCall::Args call_args = {
       connected_subchannel()->Ref(), pollent_, path->Ref(), /*start_time=*/0,
-      deadline_, arena_,
+      static_cast<Call*>(call_context()[GRPC_CONTEXT_CALL].value)->deadline(),
+      arena_,
       // TODO(roth): When we implement hedging support, we will probably
       // need to use a separate call context for each subchannel call.
       call_context(), call_combiner_};
@@ -3529,7 +3535,7 @@ ClientChannelFilter::PromiseBasedLoadBalancedCall::MakeCallPromise(
         [this]() {
           // TODO(roth): Change CallTracer API to not pass metadata
           // batch to this method, since the batch is always empty.
-          grpc_metadata_batch metadata(GetContext<Arena>());
+          grpc_metadata_batch metadata;
           call_attempt_tracer()->RecordSendTrailingMetadata(&metadata);
         });
   }