grpc 1.75.0 → 1.78.0

data/src/core/client_channel/client_channel_filter.h

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

data/src/core/client_channel/client_channel_internal.h

@@ -21,15 +21,15 @@
 
 #include <utility>
 
-#include "absl/functional/any_invocable.h"
-#include "absl/log/check.h"
 #include "src/core/call/call_destination.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/load_balancing/lb_policy.h"
 #include "src/core/service_config/service_config_call_data.h"
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/util/down_cast.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/unique_type_name.h"
+#include "absl/functional/any_invocable.h"
 
 //
 // This file contains internal interfaces used to allow various plugins
@@ -41,6 +41,10 @@
 #define GRPC_ARG_HEALTH_CHECK_SERVICE_NAME \
   "grpc.internal.health_check_service_name"
 
+// Max number of connections per subchannel.
+#define GRPC_ARG_MAX_CONNECTIONS_PER_SUBCHANNEL \
+  "grpc.internal.max_connections_per_subchannel"
+
 namespace grpc_core {
 
 // Internal type for LB call state interface.  Provides an interface for
@@ -54,8 +58,7 @@ class ClientChannelLbCallState : public LoadBalancingPolicy::CallState {
 
   virtual ServiceConfigCallData::CallAttributeInterface* GetCallAttribute(
       UniqueTypeName type) const = 0;
-  virtual ClientCallTracerInterface::CallAttemptTracer* GetCallAttemptTracer()
-      const = 0;
+  virtual CallAttemptTracer* GetCallAttemptTracer() const = 0;
 };
 
 // Internal type for ServiceConfigCallData.  Handles call commits.
@@ -65,7 +68,7 @@ class ClientChannelServiceConfigCallData final : public ServiceConfigCallData {
       : ServiceConfigCallData(arena) {}
 
   void SetOnCommit(absl::AnyInvocable<void()> on_commit) {
-    CHECK(on_commit_ == nullptr);
+    GRPC_CHECK(on_commit_ == nullptr);
     on_commit_ = std::move(on_commit);
   }
 

data/src/core/client_channel/client_channel_service_config.cc

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

data/src/core/client_channel/client_channel_service_config.h

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

data/src/core/client_channel/config_selector.h

@@ -24,9 +24,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/check.h"
-#include "absl/status/status.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/interception_chain.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/client_channel/client_channel_internal.h"
@@ -35,10 +32,13 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/service_config/service_config.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/unique_type_name.h"
 #include "src/core/util/useful.h"
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
 
 // Channel arg key for ConfigSelector.
 #define GRPC_ARG_CONFIG_SELECTOR "grpc.internal.config_selector"
@@ -100,7 +100,7 @@ class DefaultConfigSelector final : public ConfigSelector {
     // The client channel code ensures that this will never be null.
     // If neither the resolver nor the client application provide a
     // config, a default empty config will be used.
-    DCHECK(service_config_ != nullptr);
+    GRPC_DCHECK(service_config_ != nullptr);
   }
 
   UniqueTypeName name() const override {
@@ -110,7 +110,7 @@ class DefaultConfigSelector final : public ConfigSelector {
 
   absl::Status GetCallConfig(GetCallConfigArgs args) override {
     Slice* path = args.initial_metadata->get_pointer(HttpPathMetadata());
-    CHECK_NE(path, nullptr);
+    GRPC_CHECK_NE(path, nullptr);
     auto* parsed_method_configs =
         service_config_->GetMethodParsedConfigVector(path->c_slice());
     args.service_config_call_data->SetServiceConfig(service_config_,

data/src/core/client_channel/connector.h

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

data/src/core/client_channel/dynamic_filters.cc

@@ -22,9 +22,6 @@
 #include <new>
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/statusor.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channel_stack_builder_impl.h"
@@ -32,7 +29,10 @@
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/lame_client.h"
 #include "src/core/util/alloc.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/status_helper.h"
+#include "absl/log/log.h"
+#include "absl/status/statusor.h"
 
 // Conversion between call and call stack.
 #define CALL_TO_CALL_STACK(call)                                     \
@@ -80,8 +80,8 @@ void DynamicFilters::Call::StartTransportStreamOpBatch(
 }
 
 void DynamicFilters::Call::SetAfterCallStackDestroy(grpc_closure* closure) {
-  CHECK_EQ(after_call_stack_destroy_, nullptr);
-  CHECK_NE(closure, nullptr);
+  GRPC_CHECK_EQ(after_call_stack_destroy_, nullptr);
+  GRPC_CHECK_NE(closure, nullptr);
   after_call_stack_destroy_ = closure;
 }
 

data/src/core/client_channel/global_subchannel_pool.cc

@@ -26,43 +26,6 @@
 
 namespace grpc_core {
 
-RefCountedPtr<LegacyGlobalSubchannelPool>
-LegacyGlobalSubchannelPool::instance() {
-  static LegacyGlobalSubchannelPool* p = new LegacyGlobalSubchannelPool();
-  return p->RefAsSubclass<LegacyGlobalSubchannelPool>();
-}
-
-RefCountedPtr<Subchannel> LegacyGlobalSubchannelPool::RegisterSubchannel(
-    const SubchannelKey& key, RefCountedPtr<Subchannel> constructed) {
-  MutexLock lock(&mu_);
-  auto it = subchannel_map_.find(key);
-  if (it != subchannel_map_.end()) {
-    RefCountedPtr<Subchannel> existing = it->second->RefIfNonZero();
-    if (existing != nullptr) return existing;
-  }
-  subchannel_map_[key] = constructed.get();
-  return constructed;
-}
-
-void LegacyGlobalSubchannelPool::UnregisterSubchannel(const SubchannelKey& key,
-                                                      Subchannel* subchannel) {
-  MutexLock lock(&mu_);
-  auto it = subchannel_map_.find(key);
-  // delete only if key hasn't been re-registered to a different subchannel
-  // between strong-unreffing and unregistration of subchannel.
-  if (it != subchannel_map_.end() && it->second == subchannel) {
-    subchannel_map_.erase(it);
-  }
-}
-
-RefCountedPtr<Subchannel> LegacyGlobalSubchannelPool::FindSubchannel(
-    const SubchannelKey& key) {
-  MutexLock lock(&mu_);
-  auto it = subchannel_map_.find(key);
-  if (it == subchannel_map_.end()) return nullptr;
-  return it->second->RefIfNonZero();
-}
-
 RefCountedPtr<GlobalSubchannelPool> GlobalSubchannelPool::instance() {
   static GlobalSubchannelPool* p = new GlobalSubchannelPool();
   return p->RefAsSubclass<GlobalSubchannelPool>();

data/src/core/client_channel/global_subchannel_pool.h

@@ -23,40 +23,13 @@
 
 #include <map>
 
-#include "absl/base/thread_annotations.h"
 #include "src/core/client_channel/subchannel_pool_interface.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
+#include "absl/base/thread_annotations.h"
 
 namespace grpc_core {
 
-// The global subchannel pool. It shares subchannels among channels. There
-// should be only one instance of this class.
-class LegacyGlobalSubchannelPool final : public SubchannelPoolInterface {
- public:
-  // Gets the singleton instance.
-  static RefCountedPtr<LegacyGlobalSubchannelPool> instance();
-
-  // Implements interface methods.
-  RefCountedPtr<Subchannel> RegisterSubchannel(
-      const SubchannelKey& key, RefCountedPtr<Subchannel> constructed) override
-      ABSL_LOCKS_EXCLUDED(mu_);
-  void UnregisterSubchannel(const SubchannelKey& key,
-                            Subchannel* subchannel) override
-      ABSL_LOCKS_EXCLUDED(mu_);
-  RefCountedPtr<Subchannel> FindSubchannel(const SubchannelKey& key) override
-      ABSL_LOCKS_EXCLUDED(mu_);
-
- private:
-  LegacyGlobalSubchannelPool() {}
-  ~LegacyGlobalSubchannelPool() override {}
-
-  // A map from subchannel key to subchannel.
-  std::map<SubchannelKey, Subchannel*> subchannel_map_ ABSL_GUARDED_BY(mu_);
-  // To protect subchannel_map_.
-  Mutex mu_;
-};
-
 // The global subchannel pool. It shares subchannels among channels. There
 // should be only one instance of this class.
 class GlobalSubchannelPool final : public SubchannelPoolInterface {

data/src/core/client_channel/lb_metadata.h

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