grpc 1.75.0 → 1.78.1

data/src/core/client_channel/load_balanced_call_destination.cc

@@ -14,7 +14,6 @@
 
 #include "src/core/client_channel/load_balanced_call_destination.h"
 
-#include "absl/log/log.h"
 #include "src/core/call/status_util.h"
 #include "src/core/client_channel/client_channel.h"
 #include "src/core/client_channel/client_channel_internal.h"
@@ -23,16 +22,19 @@
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/promise/loop.h"
 #include "src/core/telemetry/call_tracer.h"
+#include "absl/log/log.h"
 
 namespace grpc_core {
 
 namespace {
 
 void MaybeCreateCallAttemptTracer(bool is_transparent_retry) {
-  auto* call_tracer = MaybeGetContext<ClientCallTracerInterface>();
+  auto* arena = MaybeGetContext<Arena>();
+  if (arena == nullptr) return;
+  auto* call_tracer = MaybeGetContext<ClientCallTracer>();
   if (call_tracer == nullptr) return;
   auto* tracer = call_tracer->StartNewAttempt(is_transparent_retry);
-  SetContext<CallTracerInterface>(tracer);
+  SetContext<CallAttemptTracer>(WrapCallAttemptTracer(tracer, arena));
 }
 
 class LbCallState : public ClientChannelLbCallState {
@@ -47,9 +49,8 @@ class LbCallState : public ClientChannelLbCallState {
     return service_config_call_data->GetCallAttribute(type);
   }
 
-  ClientCallTracerInterface::CallAttemptTracer* GetCallAttemptTracer()
-      const override {
-    return GetContext<ClientCallTracerInterface::CallAttemptTracer>();
+  CallAttemptTracer* GetCallAttemptTracer() const override {
+    return GetContext<CallAttemptTracer>();
   }
 };
 
@@ -134,11 +135,9 @@ LoopCtl<absl::StatusOr<RefCountedPtr<UnstartedCallDestination>>> PickSubchannel(
                  "pick";
           return Continue{};
         }
-        // If the LB policy returned a call tracker, inform it that the
-        // call is starting and add it to context, so that we can notify
-        // it when the call finishes.
+        // If the LB policy returned a call tracker, add it to context, so
+        // that we can notify it when the call finishes.
         if (complete_pick->subchannel_call_tracker != nullptr) {
-          complete_pick->subchannel_call_tracker->Start();
           SetContext(complete_pick->subchannel_call_tracker.release());
         }
         // Apply metadata mutations, if any.
@@ -240,8 +239,7 @@ void LoadBalancedCallDestination::StartCall(
               }
               // If it was queued, add a trace annotation.
               if (was_queued) {
-                auto* tracer = MaybeGetContext<
-                    ClientCallTracerInterface::CallAttemptTracer>();
+                auto* tracer = MaybeGetContext<CallAttemptTracer>();
                 if (tracer != nullptr) {
                   tracer->RecordAnnotation("Delayed LB pick complete.");
                 }

data/src/core/client_channel/load_balanced_call_destination.h

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

data/src/core/client_channel/local_subchannel_pool.cc

@@ -22,8 +22,8 @@
 
 #include <utility>
 
-#include "absl/log/check.h"
 #include "src/core/client_channel/subchannel.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -33,7 +33,7 @@ RefCountedPtr<Subchannel> LocalSubchannelPool::RegisterSubchannel(
   // Because this pool is only accessed under the client channel's work
   // serializer, and because FindSubchannel is checked before invoking
   // RegisterSubchannel, no such subchannel should exist in the map.
-  CHECK(it == subchannel_map_.end());
+  GRPC_CHECK(it == subchannel_map_.end());
   subchannel_map_[key] = constructed.get();
   return constructed;
 }
@@ -44,8 +44,8 @@ void LocalSubchannelPool::UnregisterSubchannel(const SubchannelKey& key,
   // Because this subchannel pool is accessed only under the client
   // channel's work serializer, any subchannel created by RegisterSubchannel
   // will be deleted from the map in UnregisterSubchannel.
-  CHECK(it != subchannel_map_.end());
-  CHECK(it->second == subchannel);
+  GRPC_CHECK(it != subchannel_map_.end());
+  GRPC_CHECK(it->second == subchannel);
   subchannel_map_.erase(it);
 }
 

data/src/core/client_channel/retry_filter.cc

@@ -22,8 +22,6 @@
 #include <optional>
 #include <string>
 
-#include "absl/status/statusor.h"
-#include "absl/strings/strip.h"
 #include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/client_channel/retry_filter_legacy_call_data.h"
 #include "src/core/client_channel/retry_service_config.h"
@@ -35,6 +33,8 @@
 #include "src/core/service_config/service_config_call_data.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/uri.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/strip.h"
 
 //
 // Retry filter

data/src/core/client_channel/retry_filter.h

@@ -27,7 +27,6 @@
 #include <new>
 #include <optional>
 
-#include "absl/log/check.h"
 #include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/client_channel/retry_service_config.h"
 #include "src/core/client_channel/retry_throttle.h"
@@ -36,6 +35,7 @@
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/useful.h"
 
@@ -88,8 +88,8 @@ class RetryFilter final {
 
   static grpc_error_handle Init(grpc_channel_element* elem,
                                 grpc_channel_element_args* args) {
-    CHECK(args->is_last);
-    CHECK(elem->filter == &kVtable);
+    GRPC_CHECK(args->is_last);
+    GRPC_CHECK(elem->filter == &kVtable);
     new (elem->channel_data) RetryFilter(*args);
     return absl::OkStatus();
   }

data/src/core/client_channel/retry_filter_legacy_call_data.cc

@@ -20,10 +20,6 @@
 #include <memory>
 #include <new>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/status.h"
-#include "absl/strings/str_cat.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/call/status_util.h"
 #include "src/core/client_channel/client_channel_internal.h"
@@ -44,12 +40,16 @@
 #include "src/core/util/backoff.h"
 #include "src/core/util/construct_destruct.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/time.h"
 #include "src/core/util/useful.h"
+#include "absl/log/log.h"
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
 
 namespace grpc_core {
 
@@ -293,9 +293,8 @@ namespace {
 void StartBatchInCallCombiner(void* arg, grpc_error_handle /*ignored*/) {
   grpc_transport_stream_op_batch* batch =
       static_cast<grpc_transport_stream_op_batch*>(arg);
-  auto* lb_call =
-      static_cast<ClientChannelFilter::FilterBasedLoadBalancedCall*>(
-          batch->handler_private.extra_arg);
+  auto* lb_call = static_cast<ClientChannelFilter::LoadBalancedCall*>(
+      batch->handler_private.extra_arg);
   // Note: This will release the call combiner.
   lb_call->StartTransportStreamOpBatch(batch);
 }
@@ -1502,7 +1501,7 @@ RetryFilter::LegacyCallData::~LegacyCallData() {
   FreeAllCachedSendOpData();
   // 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].batch, nullptr);
+    GRPC_CHECK_EQ(pending_batches_[i].batch, nullptr);
   }
 }
 
@@ -1626,7 +1625,7 @@ void RetryFilter::LegacyCallData::StartTransportStreamOpBatch(
   call_attempt_->StartRetriableBatches();
 }
 
-OrphanablePtr<ClientChannelFilter::FilterBasedLoadBalancedCall>
+OrphanablePtr<ClientChannelFilter::LoadBalancedCall>
 RetryFilter::LegacyCallData::CreateLoadBalancedCall(
     absl::AnyInvocable<void()> on_commit, bool is_transparent_retry) {
   grpc_call_element_args args = {owning_call_,     nullptr,
@@ -1731,7 +1730,7 @@ RetryFilter::LegacyCallData::PendingBatchesAdd(
   GRPC_TRACE_LOG(retry, INFO) << "chand=" << chand_ << " calld=" << this
                               << ": adding pending batch at index " << idx;
   PendingBatch* pending = &pending_batches_[idx];
-  CHECK_EQ(pending->batch, nullptr);
+  GRPC_CHECK_EQ(pending->batch, nullptr);
   pending->batch = batch;
   pending->send_ops_cached = false;
   // Update state in calld about pending batches.
@@ -1810,7 +1809,7 @@ void RetryFilter::LegacyCallData::FailPendingBatchInCallCombiner(
 
 // This is called via the call combiner, so access to calld is synchronized.
 void RetryFilter::LegacyCallData::PendingBatchesFail(grpc_error_handle error) {
-  CHECK(!error.ok());
+  GRPC_CHECK(!error.ok());
   if (GRPC_TRACE_FLAG_ENABLED(retry)) {
     size_t num_batches = 0;
     for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
@@ -1887,7 +1886,7 @@ void RetryFilter::LegacyCallData::StartRetryTimer(
   // Compute backoff delay.
   Duration next_attempt_timeout;
   if (server_pushback.has_value()) {
-    CHECK(*server_pushback >= Duration::Zero());
+    GRPC_CHECK(*server_pushback >= Duration::Zero());
     next_attempt_timeout = *server_pushback;
     retry_backoff_.Reset();
   } else {

data/src/core/client_channel/retry_filter_legacy_call_data.h

@@ -25,8 +25,6 @@
 #include <optional>
 #include <utility>
 
-#include "absl/container/inlined_vector.h"
-#include "absl/functional/any_invocable.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/client_channel/client_channel_filter.h"
 #include "src/core/client_channel/retry_filter.h"
@@ -47,6 +45,8 @@
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/time.h"
+#include "absl/container/inlined_vector.h"
+#include "absl/functional/any_invocable.h"
 
 namespace grpc_core {
 
@@ -252,7 +252,7 @@ class RetryFilter::LegacyCallData final {
     void MaybeCancelPerAttemptRecvTimer();
 
     LegacyCallData* calld_;
-    OrphanablePtr<ClientChannelFilter::FilterBasedLoadBalancedCall> lb_call_;
+    OrphanablePtr<ClientChannelFilter::LoadBalancedCall> lb_call_;
     bool lb_call_committed_ = false;
 
     grpc_closure on_per_attempt_recv_timer_;
@@ -362,9 +362,8 @@ class RetryFilter::LegacyCallData final {
   void AddClosureToStartTransparentRetry(CallCombinerClosureList* closures);
   static void StartTransparentRetry(void* arg, grpc_error_handle error);
 
-  OrphanablePtr<ClientChannelFilter::FilterBasedLoadBalancedCall>
-  CreateLoadBalancedCall(absl::AnyInvocable<void()> on_commit,
-                         bool is_transparent_retry);
+  OrphanablePtr<ClientChannelFilter::LoadBalancedCall> CreateLoadBalancedCall(
+      absl::AnyInvocable<void()> on_commit, bool is_transparent_retry);
 
   void CreateCallAttempt(bool is_transparent_retry);
 
@@ -391,8 +390,7 @@ class RetryFilter::LegacyCallData final {
   // LB call used when we've committed to a call attempt and the retry
   // state for that attempt is no longer needed.  This provides a fast
   // path for long-running streaming calls that minimizes overhead.
-  OrphanablePtr<ClientChannelFilter::FilterBasedLoadBalancedCall>
-      committed_call_;
+  OrphanablePtr<ClientChannelFilter::LoadBalancedCall> committed_call_;
 
   // When are are not yet fully committed to a particular call (i.e.,
   // either we might still retry or we have committed to the call but

data/src/core/client_channel/retry_service_config.cc

@@ -27,13 +27,13 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/log.h"
-#include "absl/strings/numbers.h"
-#include "absl/strings/str_cat.h"
 #include "src/core/call/status_util.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/util/json/json_channel_args.h"
+#include "absl/log/log.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
 
 // As per the retry design, we do not allow more than 5 retry attempts.
 #define MAX_MAX_RETRY_ATTEMPTS 5

data/src/core/client_channel/retry_service_config.h

@@ -24,7 +24,6 @@
 #include <memory>
 #include <optional>
 
-#include "absl/strings/string_view.h"
 #include "src/core/call/status_util.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -34,6 +33,7 @@
 #include "src/core/util/json/json_object_loader.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 {

data/src/core/client_channel/subchannel.cc

@@ -29,12 +29,6 @@
 #include <optional>
 #include <utility>
 
-#include "absl/log/check.h"
-#include "absl/log/log.h"
-#include "absl/status/statusor.h"
-#include "absl/strings/cord.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/interception_chain.h"
 #include "src/core/channelz/channel_trace.h"
 #include "src/core/channelz/channelz.h"
@@ -64,12 +58,18 @@
 #include "src/core/util/alloc.h"
 #include "src/core/util/backoff.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/useful.h"
+#include "absl/log/log.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/cord.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
 
 // Backoff parameters.
 #define GRPC_SUBCHANNEL_INITIAL_CONNECT_BACKOFF_SECONDS 1
@@ -282,8 +282,8 @@ grpc_call_stack* SubchannelCall::GetCallStack() {
 }
 
 void SubchannelCall::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;
 }
 
@@ -334,7 +334,7 @@ void SubchannelCall::MaybeInterceptRecvTrailingMetadata(
   GRPC_CLOSURE_INIT(&recv_trailing_metadata_ready_, RecvTrailingMetadataReady,
                     this, grpc_schedule_on_exec_ctx);
   // save some state needed for the interception callback.
-  CHECK_EQ(recv_trailing_metadata_, nullptr);
+  GRPC_CHECK_EQ(recv_trailing_metadata_, nullptr);
   recv_trailing_metadata_ =
       batch->payload->recv_trailing_metadata.recv_trailing_metadata;
   original_recv_trailing_metadata_ =
@@ -360,12 +360,12 @@ void GetCallStatus(grpc_status_code* status, Timestamp deadline,
 void SubchannelCall::RecvTrailingMetadataReady(void* arg,
                                                grpc_error_handle error) {
   SubchannelCall* call = static_cast<SubchannelCall*>(arg);
-  CHECK_NE(call->recv_trailing_metadata_, nullptr);
+  GRPC_CHECK_NE(call->recv_trailing_metadata_, nullptr);
   grpc_status_code status = GRPC_STATUS_OK;
   GetCallStatus(&status, call->deadline_, call->recv_trailing_metadata_, error);
   channelz::SubchannelNode* channelz_node =
       call->connected_subchannel_->channelz_node();
-  CHECK_NE(channelz_node, nullptr);
+  GRPC_CHECK_NE(channelz_node, nullptr);
   if (status == GRPC_STATUS_OK) {
     channelz_node->RecordCallSucceeded();
   } else {
@@ -422,12 +422,6 @@ class Subchannel::ConnectedSubchannelStateWatcher final
             << ": Connected subchannel " << connected_subchannel.get()
             << " reports " << ConnectivityStateName(new_state) << ": "
             << status;
-        if (c->channelz_node() != nullptr) {
-          if (connected_subchannel->channelz_node() != nullptr) {
-            connected_subchannel->channelz_node()->RemoveParent(
-                c->channelz_node());
-          }
-        }
         // If the subchannel was created from an endpoint, then we report
         // TRANSIENT_FAILURE here instead of IDLE. The subchannel will never
         // leave TRANSIENT_FAILURE state, because there is no way for us to
@@ -451,6 +445,68 @@ class Subchannel::ConnectedSubchannelStateWatcher final
   WeakRefCountedPtr<Subchannel> subchannel_;
 };
 
+//
+// Subchannel::ConnectionStateWatcher
+//
+
+class Subchannel::ConnectionStateWatcher final
+    : public Transport::StateWatcher {
+ public:
+  explicit ConnectionStateWatcher(WeakRefCountedPtr<Subchannel> subchannel)
+      : subchannel_(std::move(subchannel)) {}
+
+  ~ConnectionStateWatcher() override {
+    subchannel_.reset(DEBUG_LOCATION, "state_watcher");
+  }
+
+  void OnDisconnect(absl::Status status,
+                    DisconnectInfo disconnect_info) override {
+    MutexLock lock(&subchannel_->mu_);
+    // Handle keepalive update.
+    if (disconnect_info.keepalive_time.has_value()) {
+      subchannel_->ThrottleKeepaliveTimeLocked(*disconnect_info.keepalive_time);
+      subchannel_->watcher_list_.NotifyOnKeepaliveUpdateLocked(
+          *disconnect_info.keepalive_time);
+    }
+    // We shouldn't ever see OnDisconnect() more than once for a given
+    // connection, but we'll be defensive just in case: if the connected
+    // subchannel has already been cleared, then this becomes a no-op.
+    RefCountedPtr<ConnectedSubchannel> connected_subchannel =
+        std::move(subchannel_->connected_subchannel_);
+    if (connected_subchannel == nullptr) return;
+    GRPC_TRACE_LOG(subchannel, INFO)
+        << "subchannel " << subchannel_.get() << " "
+        << subchannel_->key_.ToString() << ": connected subchannel "
+        << connected_subchannel.get() << " reports disconnection: " << status;
+    // If the subchannel was created from an endpoint, then we report
+    // TRANSIENT_FAILURE here instead of IDLE. The subchannel will never
+    // leave TRANSIENT_FAILURE state, because there is no way for us to
+    // establish a new connection.  Otherwise, we report IDLE here.
+    if (subchannel_->created_from_endpoint_) {
+      subchannel_->SetConnectivityStateLocked(GRPC_CHANNEL_TRANSIENT_FAILURE,
+                                              status);
+    } else {
+      subchannel_->SetConnectivityStateLocked(GRPC_CHANNEL_IDLE,
+                                              absl::OkStatus());
+    }
+    subchannel_->backoff_.Reset();
+  }
+
+  void OnPeerMaxConcurrentStreamsUpdate(
+      uint32_t /*max_concurrent_streams*/,
+      std::unique_ptr<MaxConcurrentStreamsUpdateDoneHandle> /*on_done*/)
+      override {
+    // TODO(roth): Implement this as part of adding connection scaling.
+  }
+
+  grpc_pollset_set* interested_parties() const override {
+    return subchannel_->pollset_set_;
+  }
+
+ private:
+  WeakRefCountedPtr<Subchannel> subchannel_;
+};
+
 //
 // Subchannel::ConnectivityStateWatcherList
 //
@@ -474,6 +530,27 @@ void Subchannel::ConnectivityStateWatcherList::NotifyLocked(
   }
 }
 
+void Subchannel::ConnectivityStateWatcherList::NotifyOnKeepaliveUpdateLocked(
+    Duration new_keepalive_time) {
+  for (const auto& watcher : watchers_) {
+    subchannel_->work_serializer_.Run([watcher, new_keepalive_time]() {
+      watcher->OnKeepaliveUpdate(new_keepalive_time);
+    });
+  }
+}
+
+uint32_t
+Subchannel::ConnectivityStateWatcherList::GetMaxConnectionsPerSubchannel()
+    const {
+  uint32_t max_connections_per_subchannel = 1;
+  for (const auto& watcher : watchers_) {
+    max_connections_per_subchannel =
+        std::max(max_connections_per_subchannel,
+                 watcher->max_connections_per_subchannel());
+  }
+  return max_connections_per_subchannel;
+}
+
 //
 // Subchannel
 //
@@ -585,7 +662,7 @@ RefCountedPtr<Subchannel> Subchannel::Create(
     const grpc_resolved_address& address, const ChannelArgs& args) {
   SubchannelKey key(address, args);
   auto* subchannel_pool = args.GetObject<SubchannelPoolInterface>();
-  CHECK_NE(subchannel_pool, nullptr);
+  GRPC_CHECK_NE(subchannel_pool, nullptr);
   RefCountedPtr<Subchannel> c = subchannel_pool->FindSubchannel(key);
   if (c != nullptr) {
     return c;
@@ -610,15 +687,19 @@ RefCountedPtr<Subchannel> Subchannel::Create(
   return registered;
 }
 
-void Subchannel::ThrottleKeepaliveTime(int new_keepalive_time) {
+void Subchannel::ThrottleKeepaliveTime(Duration new_keepalive_time) {
   MutexLock lock(&mu_);
+  ThrottleKeepaliveTimeLocked(new_keepalive_time);
+}
+
+void Subchannel::ThrottleKeepaliveTimeLocked(Duration new_keepalive_time) {
   // Only update the value if the new keepalive time is larger.
   if (new_keepalive_time > keepalive_time_) {
     keepalive_time_ = new_keepalive_time;
     GRPC_TRACE_LOG(subchannel, INFO)
         << "subchannel " << this << " " << key_.ToString()
         << ": throttling keepalive time to " << new_keepalive_time;
-    args_ = args_.Set(GRPC_ARG_KEEPALIVE_TIME_MS, new_keepalive_time);
+    args_ = args_.Set(GRPC_ARG_KEEPALIVE_TIME_MS, new_keepalive_time.millis());
   }
 }
 
@@ -681,7 +762,7 @@ void Subchannel::Orphaned() {
     subchannel_pool_.reset();
   }
   MutexLock lock(&mu_);
-  CHECK(!shutdown_);
+  GRPC_CHECK(!shutdown_);
   shutdown_ = true;
   connector_.reset();
   connected_subchannel_.reset();
@@ -821,6 +902,11 @@ void Subchannel::OnConnectingFinishedLocked(grpc_error_handle error) {
 
 bool Subchannel::PublishTransportLocked() {
   auto socket_node = connecting_result_.transport->GetSocketNode();
+  if (IsTransportStateWatcherEnabled()) {
+    connecting_result_.transport->StartWatch(
+        MakeRefCounted<ConnectionStateWatcher>(
+            WeakRef(DEBUG_LOCATION, "state_watcher")));
+  }
   if (connecting_result_.transport->filter_stack_transport() != nullptr) {
     // Construct channel stack.
     // Builder takes ownership of transport.
@@ -890,10 +976,11 @@ bool Subchannel::PublishTransportLocked() {
       socket_node->AddParent(channelz_node_.get());
     }
   }
-  // Start watching connected subchannel.
-  connected_subchannel_->StartWatch(
-      pollset_set_, MakeOrphanable<ConnectedSubchannelStateWatcher>(
-                        WeakRef(DEBUG_LOCATION, "state_watcher")));
+  if (!IsTransportStateWatcherEnabled()) {
+    connected_subchannel_->StartWatch(
+        pollset_set_, MakeOrphanable<ConnectedSubchannelStateWatcher>(
+                          WeakRef(DEBUG_LOCATION, "state_watcher")));
+  }
   // Report initial state.
   SetConnectivityStateLocked(GRPC_CHANNEL_READY, absl::Status());
   return true;
@@ -919,6 +1006,8 @@ ChannelArgs Subchannel::MakeSubchannelArgs(
       // uniqueness.
       .Remove(GRPC_ARG_HEALTH_CHECK_SERVICE_NAME)
       .Remove(GRPC_ARG_INHIBIT_HEALTH_CHECKING)
+      .Remove(GRPC_ARG_MAX_CONNECTIONS_PER_SUBCHANNEL)
+      .Remove(GRPC_ARG_MAX_CONNECTIONS_PER_SUBCHANNEL_CAP)
       .Remove(GRPC_ARG_CHANNELZ_CHANNEL_NODE)
       // Remove all keys with the no-subchannel prefix.
       .RemoveAllKeysWithPrefix(GRPC_ARG_NO_SUBCHANNEL_PREFIX);

data/src/core/client_channel/subchannel.h

@@ -26,9 +26,6 @@
 #include <map>
 #include <memory>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/container/flat_hash_set.h"
-#include "absl/status/status.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/client_channel/connector.h"
 #include "src/core/client_channel/subchannel_pool_interface.h"
@@ -57,6 +54,9 @@
 #include "src/core/util/time_precise.h"
 #include "src/core/util/unique_type_name.h"
 #include "src/core/util/work_serializer.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/status/status.h"
 
 /** This arg is intended for internal use only, primarily
  *  for passing endpoint information during subchannel creation or connection.
@@ -71,6 +71,7 @@ class ConnectedSubchannel : public RefCounted<ConnectedSubchannel> {
  public:
   const ChannelArgs& args() const { return args_; }
 
+  // TODO(roth): Remove this when transport_state_watcher experiment is removed.
   virtual void StartWatch(
       grpc_pollset_set* interested_parties,
       OrphanablePtr<ConnectivityStateWatcherInterface> watcher) = 0;
@@ -167,8 +168,6 @@ class SubchannelCall final {
 // (SubchannelWrapper) that "converts" between the two.
 class Subchannel final : public DualRefCounted<Subchannel> {
  public:
-  // TODO(roth): Once we remove pollset_set, consider whether this can
-  // just use the normal AsyncConnectivityStateWatcherInterface API.
   class ConnectivityStateWatcherInterface
       : public RefCounted<ConnectivityStateWatcherInterface> {
    public:
@@ -178,6 +177,11 @@ class Subchannel final : public DualRefCounted<Subchannel> {
     virtual void OnConnectivityStateChange(grpc_connectivity_state state,
                                            const absl::Status& status) = 0;
 
+    // Invoked to report updated keepalive time.
+    virtual void OnKeepaliveUpdate(Duration keepalive_time) = 0;
+
+    virtual uint32_t max_connections_per_subchannel() const = 0;
+
     virtual grpc_pollset_set* interested_parties() = 0;
   };
 
@@ -208,7 +212,8 @@ class Subchannel final : public DualRefCounted<Subchannel> {
   // Throttles keepalive time to \a new_keepalive_time iff \a new_keepalive_time
   // is larger than the subchannel's current keepalive time. The updated value
   // will have an affect when the subchannel creates a new ConnectedSubchannel.
-  void ThrottleKeepaliveTime(int new_keepalive_time) ABSL_LOCKS_EXCLUDED(mu_);
+  void ThrottleKeepaliveTime(Duration new_keepalive_time)
+      ABSL_LOCKS_EXCLUDED(mu_);
 
   grpc_pollset_set* pollset_set() const { return pollset_set_; }
 
@@ -302,10 +307,15 @@ class Subchannel final : public DualRefCounted<Subchannel> {
     void NotifyLocked(grpc_connectivity_state state,
                       const absl::Status& status);
 
+    // Notifies all watchers about a keepalive update.
+    void NotifyOnKeepaliveUpdateLocked(Duration new_keepalive_time);
+
     void Clear() { watchers_.clear(); }
 
     bool empty() const { return watchers_.empty(); }
 
+    uint32_t GetMaxConnectionsPerSubchannel() const;
+
    private:
     Subchannel* subchannel_;
     absl::flat_hash_set<RefCountedPtr<ConnectivityStateWatcherInterface>,
@@ -314,13 +324,19 @@ class Subchannel final : public DualRefCounted<Subchannel> {
         watchers_;
   };
 
+  // TODO(roth): Remove this when transport_state_watcher experiment is removed.
   class ConnectedSubchannelStateWatcher;
 
+  class ConnectionStateWatcher;
+
   // Sets the subchannel's connectivity state to \a state.
   void SetConnectivityStateLocked(grpc_connectivity_state state,
                                   const absl::Status& status)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
+  void ThrottleKeepaliveTimeLocked(Duration new_keepalive_time)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+
   // Methods for connection.
   void OnRetryTimer() ABSL_LOCKS_EXCLUDED(mu_);
   void OnRetryTimerLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
@@ -383,8 +399,8 @@ class Subchannel final : public DualRefCounted<Subchannel> {
   grpc_event_engine::experimental::EventEngine::TaskHandle retry_timer_handle_
       ABSL_GUARDED_BY(mu_);
 
-  // Keepalive time period (-1 for unset)
-  int keepalive_time_ ABSL_GUARDED_BY(mu_) = -1;
+  // Keepalive time period
+  Duration keepalive_time_ ABSL_GUARDED_BY(mu_);
 
   // Data producer map.
   std::map<UniqueTypeName, DataProducerInterface*> data_producer_map_