grpc 1.42.0 → 1.46.3

data/src/core/ext/filters/client_channel/retry_service_config.cc

@@ -31,12 +31,13 @@
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
-#include "src/core/ext/filters/client_channel/server_address.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/status_util.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/json/json_util.h"
+#include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 // As per the retry design, we do not allow more than 5 retry attempts.
@@ -45,16 +46,13 @@
 namespace grpc_core {
 namespace internal {
 
-namespace {
-size_t g_retry_service_config_parser_index;
-}
-
 size_t RetryServiceConfigParser::ParserIndex() {
-  return g_retry_service_config_parser_index;
+  return CoreConfiguration::Get().service_config_parser().GetParserIndex(
+      parser_name());
 }
 
-void RetryServiceConfigParser::Register() {
-  g_retry_service_config_parser_index = ServiceConfigParser::RegisterParser(
+void RetryServiceConfigParser::Register(CoreConfiguration::Builder* builder) {
+  builder->service_config_parser()->RegisterParser(
       absl::make_unique<RetryServiceConfigParser>());
 }
 
@@ -160,9 +158,9 @@ namespace {
 
 grpc_error_handle ParseRetryPolicy(
     const grpc_channel_args* args, const Json& json, int* max_attempts,
-    grpc_millis* initial_backoff, grpc_millis* max_backoff,
-    float* backoff_multiplier, StatusCodeSet* retryable_status_codes,
-    absl::optional<grpc_millis>* per_attempt_recv_timeout) {
+    Duration* initial_backoff, Duration* max_backoff, float* backoff_multiplier,
+    StatusCodeSet* retryable_status_codes,
+    absl::optional<Duration>* per_attempt_recv_timeout) {
   if (json.type() != Json::Type::OBJECT) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "field:retryPolicy error:should be of type object");
@@ -194,14 +192,14 @@ grpc_error_handle ParseRetryPolicy(
   // Parse initialBackoff.
   if (ParseJsonObjectFieldAsDuration(json.object_value(), "initialBackoff",
                                      initial_backoff, &error_list) &&
-      *initial_backoff == 0) {
+      *initial_backoff == Duration::Zero()) {
     error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "field:initialBackoff error:must be greater than 0"));
   }
   // Parse maxBackoff.
   if (ParseJsonObjectFieldAsDuration(json.object_value(), "maxBackoff",
                                      max_backoff, &error_list) &&
-      *max_backoff == 0) {
+      *max_backoff == Duration::Zero()) {
     error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
         "field:maxBackoff error:must be greater than 0"));
   }
@@ -255,7 +253,7 @@ grpc_error_handle ParseRetryPolicy(
                                   false)) {
     it = json.object_value().find("perAttemptRecvTimeout");
     if (it != json.object_value().end()) {
-      grpc_millis per_attempt_recv_timeout_value;
+      Duration per_attempt_recv_timeout_value;
       if (!ParseDurationFromJson(it->second, &per_attempt_recv_timeout_value)) {
         error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
             "field:perAttemptRecvTimeout error:type must be STRING of the "
@@ -264,7 +262,7 @@ grpc_error_handle ParseRetryPolicy(
         *per_attempt_recv_timeout = per_attempt_recv_timeout_value;
         // TODO(roth): As part of implementing hedging, relax this check such
         // that we allow a value of 0 if a hedging policy is specified.
-        if (per_attempt_recv_timeout_value == 0) {
+        if (per_attempt_recv_timeout_value == Duration::Zero()) {
           error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
               "field:perAttemptRecvTimeout error:must be greater than 0"));
         }
@@ -298,11 +296,11 @@ RetryServiceConfigParser::ParsePerMethodParams(const grpc_channel_args* args,
   auto it = json.object_value().find("retryPolicy");
   if (it == json.object_value().end()) return nullptr;
   int max_attempts = 0;
-  grpc_millis initial_backoff = 0;
-  grpc_millis max_backoff = 0;
+  Duration initial_backoff;
+  Duration max_backoff;
   float backoff_multiplier = 0;
   StatusCodeSet retryable_status_codes;
-  absl::optional<grpc_millis> per_attempt_recv_timeout;
+  absl::optional<Duration> per_attempt_recv_timeout;
   *error = ParseRetryPolicy(args, it->second, &max_attempts, &initial_backoff,
                             &max_backoff, &backoff_multiplier,
                             &retryable_status_codes, &per_attempt_recv_timeout);

data/src/core/ext/filters/client_channel/retry_service_config.h

@@ -22,9 +22,10 @@
 #include <memory>
 
 #include "src/core/ext/filters/client_channel/retry_throttle.h"
-#include "src/core/ext/service_config/service_config_parser.h"
 #include "src/core/lib/channel/status_util.h"
-#include "src/core/lib/iomgr/exec_ctx.h"  // for grpc_millis
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/service_config/service_config_parser.h"
 
 namespace grpc_core {
 namespace internal {
@@ -45,10 +46,10 @@ class RetryGlobalConfig : public ServiceConfigParser::ParsedConfig {
 
 class RetryMethodConfig : public ServiceConfigParser::ParsedConfig {
  public:
-  RetryMethodConfig(int max_attempts, grpc_millis initial_backoff,
-                    grpc_millis max_backoff, float backoff_multiplier,
+  RetryMethodConfig(int max_attempts, Duration initial_backoff,
+                    Duration max_backoff, float backoff_multiplier,
                     StatusCodeSet retryable_status_codes,
-                    absl::optional<grpc_millis> per_attempt_recv_timeout)
+                    absl::optional<Duration> per_attempt_recv_timeout)
       : max_attempts_(max_attempts),
         initial_backoff_(initial_backoff),
         max_backoff_(max_backoff),
@@ -57,27 +58,29 @@ class RetryMethodConfig : public ServiceConfigParser::ParsedConfig {
         per_attempt_recv_timeout_(per_attempt_recv_timeout) {}
 
   int max_attempts() const { return max_attempts_; }
-  grpc_millis initial_backoff() const { return initial_backoff_; }
-  grpc_millis max_backoff() const { return max_backoff_; }
+  Duration initial_backoff() const { return initial_backoff_; }
+  Duration max_backoff() const { return max_backoff_; }
   float backoff_multiplier() const { return backoff_multiplier_; }
   StatusCodeSet retryable_status_codes() const {
     return retryable_status_codes_;
   }
-  absl::optional<grpc_millis> per_attempt_recv_timeout() const {
+  absl::optional<Duration> per_attempt_recv_timeout() const {
     return per_attempt_recv_timeout_;
   }
 
  private:
   int max_attempts_ = 0;
-  grpc_millis initial_backoff_ = 0;
-  grpc_millis max_backoff_ = 0;
+  Duration initial_backoff_;
+  Duration max_backoff_;
   float backoff_multiplier_ = 0;
   StatusCodeSet retryable_status_codes_;
-  absl::optional<grpc_millis> per_attempt_recv_timeout_;
+  absl::optional<Duration> per_attempt_recv_timeout_;
 };
 
 class RetryServiceConfigParser : public ServiceConfigParser::Parser {
  public:
+  absl::string_view name() const override { return parser_name(); }
+
   std::unique_ptr<ServiceConfigParser::ParsedConfig> ParseGlobalParams(
       const grpc_channel_args* /*args*/, const Json& json,
       grpc_error_handle* error) override;
@@ -87,7 +90,10 @@ class RetryServiceConfigParser : public ServiceConfigParser::Parser {
       grpc_error_handle* error) override;
 
   static size_t ParserIndex();
-  static void Register();
+  static void Register(CoreConfiguration::Builder* builder);
+
+ private:
+  static absl::string_view parser_name() { return "retry"; }
 };
 
 }  // namespace internal

data/src/core/ext/filters/client_channel/retry_throttle.cc

@@ -119,42 +119,28 @@ void ServerRetryThrottleData::RecordSuccess() {
 // ServerRetryThrottleMap
 //
 
-using StringToDataMap =
-    std::map<std::string, RefCountedPtr<ServerRetryThrottleData>>;
-static gpr_mu g_mu;
-static StringToDataMap* g_map;
-
-void ServerRetryThrottleMap::Init() {
-  gpr_mu_init(&g_mu);
-  g_map = new StringToDataMap();
-}
-
-void ServerRetryThrottleMap::Shutdown() {
-  gpr_mu_destroy(&g_mu);
-  delete g_map;
-  g_map = nullptr;
+ServerRetryThrottleMap* ServerRetryThrottleMap::Get() {
+  static ServerRetryThrottleMap* m = new ServerRetryThrottleMap();
+  return m;
 }
 
 RefCountedPtr<ServerRetryThrottleData> ServerRetryThrottleMap::GetDataForServer(
     const std::string& server_name, intptr_t max_milli_tokens,
     intptr_t milli_token_ratio) {
-  RefCountedPtr<ServerRetryThrottleData> result;
-  gpr_mu_lock(&g_mu);
-  auto it = g_map->find(server_name);
+  MutexLock lock(&mu_);
+  auto it = map_.find(server_name);
   ServerRetryThrottleData* throttle_data =
-      it == g_map->end() ? nullptr : it->second.get();
+      it == map_.end() ? nullptr : it->second.get();
   if (throttle_data == nullptr ||
       throttle_data->max_milli_tokens() != max_milli_tokens ||
       throttle_data->milli_token_ratio() != milli_token_ratio) {
     // Entry not found, or found with old parameters.  Create a new one.
-    it = g_map
-             ->emplace(server_name,
-                       MakeRefCounted<ServerRetryThrottleData>(
-                           max_milli_tokens, milli_token_ratio, throttle_data))
+    it = map_.emplace(server_name,
+                      MakeRefCounted<ServerRetryThrottleData>(
+                          max_milli_tokens, milli_token_ratio, throttle_data))
              .first;
     throttle_data = it->second.get();
   }
-  gpr_mu_unlock(&g_mu);
   return throttle_data->Ref();
 }
 

data/src/core/ext/filters/client_channel/retry_throttle.h

@@ -21,10 +21,12 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <map>
 #include <string>
 
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_core {
 namespace internal {
@@ -61,16 +63,20 @@ class ServerRetryThrottleData : public RefCounted<ServerRetryThrottleData> {
 /// Global map of server name to retry throttle data.
 class ServerRetryThrottleMap {
  public:
-  /// Initializes global map of failure data for each server name.
-  static void Init();
-  /// Shuts down global map of failure data for each server name.
-  static void Shutdown();
+  static ServerRetryThrottleMap* Get();
 
   /// Returns the failure data for \a server_name, creating a new entry if
   /// needed.
-  static RefCountedPtr<ServerRetryThrottleData> GetDataForServer(
+  RefCountedPtr<ServerRetryThrottleData> GetDataForServer(
       const std::string& server_name, intptr_t max_milli_tokens,
       intptr_t milli_token_ratio);
+
+ private:
+  using StringToDataMap =
+      std::map<std::string, RefCountedPtr<ServerRetryThrottleData>>;
+
+  Mutex mu_;
+  StringToDataMap map_ ABSL_GUARDED_BY(mu_);
 };
 
 }  // namespace internal

data/src/core/ext/filters/client_channel/service_config_channel_arg_filter.cc

@@ -19,11 +19,12 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/service_config/service_config_call_data.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.h"
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/service_config/service_config_call_data.h"
+#include "src/core/lib/service_config/service_config_impl.h"
 
 namespace grpc_core {
 
@@ -37,7 +38,7 @@ class ServiceConfigChannelArgChannelData {
         args->channel_args, GRPC_ARG_SERVICE_CONFIG);
     if (service_config_str != nullptr) {
       grpc_error_handle service_config_error = GRPC_ERROR_NONE;
-      auto service_config = ServiceConfig::Create(
+      auto service_config = ServiceConfigImpl::Create(
           args->channel_args, service_config_str, &service_config_error);
       if (service_config_error == GRPC_ERROR_NONE) {
         service_config_ = std::move(service_config);
@@ -123,6 +124,7 @@ void ServiceConfigChannelArgDestroyChannelElem(grpc_channel_element* elem) {
 
 const grpc_channel_filter ServiceConfigChannelArgFilter = {
     grpc_call_next_op,
+    nullptr,
     grpc_channel_next_op,
     sizeof(ServiceConfigChannelArgCallData),
     ServiceConfigChannelArgInitCallElem,
@@ -140,16 +142,15 @@ void RegisterServiceConfigChannelArgFilter(
     CoreConfiguration::Builder* builder) {
   builder->channel_init()->RegisterStage(
       GRPC_CLIENT_DIRECT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      [](grpc_channel_stack_builder* builder) {
-        const grpc_channel_args* channel_args =
-            grpc_channel_stack_builder_get_channel_arguments(builder);
+      [](ChannelStackBuilder* builder) {
+        const grpc_channel_args* channel_args = builder->channel_args();
         if (grpc_channel_args_want_minimal_stack(channel_args) ||
             grpc_channel_args_find_string(channel_args,
                                           GRPC_ARG_SERVICE_CONFIG) == nullptr) {
           return true;
         }
-        return grpc_channel_stack_builder_prepend_filter(
-            builder, &ServiceConfigChannelArgFilter, nullptr, nullptr);
+        builder->PrependFilter(&ServiceConfigChannelArgFilter, nullptr);
+        return true;
       });
 }
 

data/src/core/ext/filters/client_channel/subchannel.cc

@@ -26,6 +26,7 @@
 
 #include "absl/strings/str_format.h"
 
+#include <grpc/status.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
@@ -37,6 +38,7 @@
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_stack_builder_impl.h"
 #include "src/core/lib/channel/connected_channel.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/stats.h"
@@ -50,7 +52,6 @@
 #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/status_metadata.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 // Strong and weak refs.
@@ -141,14 +142,14 @@ SubchannelCall::SubchannelCall(Args args, grpc_error_handle* error)
       deadline_(args.deadline) {
   grpc_call_stack* callstk = SUBCHANNEL_CALL_TO_CALL_STACK(this);
   const grpc_call_element_args call_args = {
-      callstk,           /* call_stack */
-      nullptr,           /* server_transport_data */
-      args.context,      /* context */
-      args.path,         /* path */
-      args.start_time,   /* start_time */
-      args.deadline,     /* deadline */
-      args.arena,        /* arena */
-      args.call_combiner /* call_combiner */
+      callstk,             /* call_stack */
+      nullptr,             /* server_transport_data */
+      args.context,        /* context */
+      args.path.c_slice(), /* path */
+      args.start_time,     /* start_time */
+      args.deadline,       /* deadline */
+      args.arena,          /* arena */
+      args.call_combiner   /* call_combiner */
   };
   *error = grpc_call_stack_init(connected_subchannel_->channel_stack(), 1,
                                 SubchannelCall::Destroy, this, &call_args);
@@ -188,8 +189,8 @@ RefCountedPtr<SubchannelCall> SubchannelCall::Ref() {
   return RefCountedPtr<SubchannelCall>(this);
 }
 
-RefCountedPtr<SubchannelCall> SubchannelCall::Ref(
-    const grpc_core::DebugLocation& location, const char* reason) {
+RefCountedPtr<SubchannelCall> SubchannelCall::Ref(const DebugLocation& location,
+                                                  const char* reason) {
   IncrementRefCount(location, reason);
   return RefCountedPtr<SubchannelCall>(this);
 }
@@ -247,17 +248,12 @@ void SubchannelCall::MaybeInterceptRecvTrailingMetadata(
 namespace {
 
 // Sets *status based on the rest of the parameters.
-void GetCallStatus(grpc_status_code* status, grpc_millis deadline,
+void GetCallStatus(grpc_status_code* status, Timestamp deadline,
                    grpc_metadata_batch* md_batch, grpc_error_handle error) {
   if (error != GRPC_ERROR_NONE) {
     grpc_error_get_status(error, deadline, status, nullptr, nullptr, nullptr);
   } else {
-    if (md_batch->legacy_index()->named.grpc_status != nullptr) {
-      *status = grpc_get_status_code_from_metadata(
-          md_batch->legacy_index()->named.grpc_status->md);
-    } else {
-      *status = GRPC_STATUS_UNKNOWN;
-    }
+    *status = md_batch->get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN);
   }
   GRPC_ERROR_UNREF(error);
 }
@@ -287,8 +283,8 @@ void SubchannelCall::IncrementRefCount() {
   GRPC_CALL_STACK_REF(SUBCHANNEL_CALL_TO_CALL_STACK(this), "");
 }
 
-void SubchannelCall::IncrementRefCount(
-    const grpc_core::DebugLocation& /*location*/, const char* reason) {
+void SubchannelCall::IncrementRefCount(const DebugLocation& /*location*/,
+                                       const char* reason) {
   GRPC_CALL_STACK_REF(SUBCHANNEL_CALL_TO_CALL_STACK(this), reason);
 }
 
@@ -492,14 +488,14 @@ class Subchannel::HealthWatcherMap::HealthWatcher
   void StartHealthCheckingLocked()
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(subchannel_->mu_) {
     GPR_ASSERT(health_check_client_ == nullptr);
-    health_check_client_ = MakeOrphanable<HealthCheckClient>(
+    health_check_client_ = MakeHealthCheckClient(
         health_check_service_name_, subchannel_->connected_subchannel_,
         subchannel_->pollset_set_, subchannel_->channelz_node_, Ref());
   }
 
   WeakRefCountedPtr<Subchannel> subchannel_;
   std::string health_check_service_name_;
-  OrphanablePtr<HealthCheckClient> health_check_client_;
+  OrphanablePtr<SubchannelStreamClient> health_check_client_;
   grpc_connectivity_state state_;
   absl::Status status_;
   ConnectivityStateWatcherList watcher_list_;
@@ -573,52 +569,55 @@ void Subchannel::HealthWatcherMap::ShutdownLocked() { map_.clear(); }
 
 namespace {
 
-BackOff::Options ParseArgsForBackoffValues(
-    const grpc_channel_args* args, grpc_millis* min_connect_timeout_ms) {
-  grpc_millis initial_backoff_ms =
-      GRPC_SUBCHANNEL_INITIAL_CONNECT_BACKOFF_SECONDS * 1000;
-  *min_connect_timeout_ms =
-      GRPC_SUBCHANNEL_RECONNECT_MIN_TIMEOUT_SECONDS * 1000;
-  grpc_millis max_backoff_ms =
-      GRPC_SUBCHANNEL_RECONNECT_MAX_BACKOFF_SECONDS * 1000;
+BackOff::Options ParseArgsForBackoffValues(const grpc_channel_args* args,
+                                           Duration* min_connect_timeout) {
+  Duration initial_backoff =
+      Duration::Seconds(GRPC_SUBCHANNEL_INITIAL_CONNECT_BACKOFF_SECONDS);
+  *min_connect_timeout =
+      Duration::Seconds(GRPC_SUBCHANNEL_RECONNECT_MIN_TIMEOUT_SECONDS);
+  Duration max_backoff =
+      Duration::Seconds(GRPC_SUBCHANNEL_RECONNECT_MAX_BACKOFF_SECONDS);
   bool fixed_reconnect_backoff = false;
   if (args != nullptr) {
     for (size_t i = 0; i < args->num_args; i++) {
       if (0 == strcmp(args->args[i].key,
                       "grpc.testing.fixed_reconnect_backoff_ms")) {
         fixed_reconnect_backoff = true;
-        initial_backoff_ms = *min_connect_timeout_ms = max_backoff_ms =
-            grpc_channel_arg_get_integer(
+        initial_backoff = *min_connect_timeout = max_backoff =
+            Duration::Milliseconds(grpc_channel_arg_get_integer(
                 &args->args[i],
-                {static_cast<int>(initial_backoff_ms), 100, INT_MAX});
+                {static_cast<int>(initial_backoff.millis()), 100, INT_MAX}));
       } else if (0 ==
                  strcmp(args->args[i].key, GRPC_ARG_MIN_RECONNECT_BACKOFF_MS)) {
         fixed_reconnect_backoff = false;
-        *min_connect_timeout_ms = grpc_channel_arg_get_integer(
-            &args->args[i],
-            {static_cast<int>(*min_connect_timeout_ms), 100, INT_MAX});
+        *min_connect_timeout =
+            Duration::Milliseconds(grpc_channel_arg_get_integer(
+                &args->args[i],
+                {static_cast<int>(min_connect_timeout->millis()), 100,
+                 INT_MAX}));
       } else if (0 ==
                  strcmp(args->args[i].key, GRPC_ARG_MAX_RECONNECT_BACKOFF_MS)) {
         fixed_reconnect_backoff = false;
-        max_backoff_ms = grpc_channel_arg_get_integer(
-            &args->args[i], {static_cast<int>(max_backoff_ms), 100, INT_MAX});
+        max_backoff = Duration::Milliseconds(grpc_channel_arg_get_integer(
+            &args->args[i],
+            {static_cast<int>(max_backoff.millis()), 100, INT_MAX}));
       } else if (0 == strcmp(args->args[i].key,
                              GRPC_ARG_INITIAL_RECONNECT_BACKOFF_MS)) {
         fixed_reconnect_backoff = false;
-        initial_backoff_ms = grpc_channel_arg_get_integer(
+        initial_backoff = Duration::Milliseconds(grpc_channel_arg_get_integer(
             &args->args[i],
-            {static_cast<int>(initial_backoff_ms), 100, INT_MAX});
+            {static_cast<int>(initial_backoff.millis()), 100, INT_MAX}));
       }
     }
   }
   return BackOff::Options()
-      .set_initial_backoff(initial_backoff_ms)
+      .set_initial_backoff(initial_backoff)
       .set_multiplier(fixed_reconnect_backoff
                           ? 1.0
                           : GRPC_SUBCHANNEL_RECONNECT_BACKOFF_MULTIPLIER)
       .set_jitter(fixed_reconnect_backoff ? 0.0
                                           : GRPC_SUBCHANNEL_RECONNECT_JITTER)
-      .set_max_backoff(max_backoff_ms);
+      .set_max_backoff(max_backoff);
 }
 
 }  // namespace
@@ -647,7 +646,7 @@ Subchannel::Subchannel(SubchannelKey key,
       key_(std::move(key)),
       pollset_set_(grpc_pollset_set_create()),
       connector_(std::move(connector)),
-      backoff_(ParseArgsForBackoffValues(args, &min_connect_timeout_ms_)) {
+      backoff_(ParseArgsForBackoffValues(args, &min_connect_timeout_)) {
   GRPC_STATS_INC_CLIENT_SUBCHANNELS_CREATED();
   GRPC_CLOSURE_INIT(&on_connecting_finished_, OnConnectingFinished, this,
                     grpc_schedule_on_exec_ctx);
@@ -883,14 +882,14 @@ void Subchannel::MaybeStartConnectingLocked() {
   } else {
     GPR_ASSERT(!have_retry_alarm_);
     have_retry_alarm_ = true;
-    const grpc_millis time_til_next =
+    const Duration time_til_next =
         next_attempt_deadline_ - ExecCtx::Get()->Now();
-    if (time_til_next <= 0) {
+    if (time_til_next <= Duration::Zero()) {
       gpr_log(GPR_INFO, "subchannel %p %s: Retry immediately", this,
               key_.ToString().c_str());
     } else {
       gpr_log(GPR_INFO, "subchannel %p %s: Retry in %" PRId64 " milliseconds",
-              this, key_.ToString().c_str(), time_til_next);
+              this, key_.ToString().c_str(), time_til_next.millis());
     }
     GRPC_CLOSURE_INIT(&on_retry_alarm_, OnRetryAlarm, this,
                       grpc_schedule_on_exec_ctx);
@@ -927,8 +926,7 @@ void Subchannel::ContinueConnectingLocked() {
   SubchannelConnector::Args args;
   args.address = &address_for_connect_;
   args.interested_parties = pollset_set_;
-  const grpc_millis min_deadline =
-      min_connect_timeout_ms_ + ExecCtx::Get()->Now();
+  const Timestamp min_deadline = min_connect_timeout_ + ExecCtx::Get()->Now();
   next_attempt_deadline_ = backoff_.NextAttemptTime();
   args.deadline = std::max(next_attempt_deadline_, min_deadline);
   args.channel_args = args_;
@@ -969,20 +967,15 @@ void ConnectionDestroy(void* arg, grpc_error_handle /*error*/) {
 
 bool Subchannel::PublishTransportLocked() {
   // Construct channel stack.
-  grpc_channel_stack_builder* builder = grpc_channel_stack_builder_create();
-  grpc_channel_stack_builder_set_channel_arguments(
-      builder, connecting_result_.channel_args);
-  grpc_channel_stack_builder_set_transport(builder,
-                                           connecting_result_.transport);
-  if (!CoreConfiguration::Get().channel_init().CreateStack(
-          builder, GRPC_CLIENT_SUBCHANNEL)) {
-    grpc_channel_stack_builder_destroy(builder);
+  ChannelStackBuilderImpl builder("subchannel", GRPC_CLIENT_SUBCHANNEL);
+  builder.SetChannelArgs(connecting_result_.channel_args)
+      .SetTransport(connecting_result_.transport);
+  if (!CoreConfiguration::Get().channel_init().CreateStack(&builder)) {
     return false;
   }
   grpc_channel_stack* stk;
-  grpc_error_handle error = grpc_channel_stack_builder_finish(
-      builder, 0, 1, ConnectionDestroy, nullptr,
-      reinterpret_cast<void**>(&stk));
+  grpc_error_handle error = builder.Build(0, 1, ConnectionDestroy, nullptr,
+                                          reinterpret_cast<void**>(&stk));
   if (error != GRPC_ERROR_NONE) {
     grpc_transport_destroy(connecting_result_.transport);
     gpr_log(GPR_ERROR,

data/src/core/ext/filters/client_channel/subchannel.h

@@ -27,15 +27,14 @@
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/gpr/time_precise.h"
-#include "src/core/lib/gprpp/arena.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/transport/connectivity_state.h"
-#include "src/core/lib/transport/metadata.h"
 
 namespace grpc_core {
 
@@ -75,9 +74,9 @@ class SubchannelCall {
   struct Args {
     RefCountedPtr<ConnectedSubchannel> connected_subchannel;
     grpc_polling_entity* pollent;
-    grpc_slice path;
+    Slice path;
     gpr_cycle_counter start_time;
-    grpc_millis deadline;
+    Timestamp deadline;
     Arena* arena;
     grpc_call_context_element* context;
     CallCombiner* call_combiner;
@@ -130,7 +129,7 @@ class SubchannelCall {
   grpc_closure recv_trailing_metadata_ready_;
   grpc_closure* original_recv_trailing_metadata_ = nullptr;
   grpc_metadata_batch* recv_trailing_metadata_ = nullptr;
-  grpc_millis deadline_;
+  Timestamp deadline_;
 };
 
 // A subchannel that knows how to connect to exactly one target address. It
@@ -361,10 +360,11 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // The map of watchers with health check service names.
   HealthWatcherMap health_watcher_map_ ABSL_GUARDED_BY(mu_);
 
+  // Minimum connect timeout - must be located before backoff_.
+  Duration min_connect_timeout_ ABSL_GUARDED_BY(mu_);
   // Backoff state.
   BackOff backoff_ ABSL_GUARDED_BY(mu_);
-  grpc_millis next_attempt_deadline_ ABSL_GUARDED_BY(mu_);
-  grpc_millis min_connect_timeout_ms_ ABSL_GUARDED_BY(mu_);
+  Timestamp next_attempt_deadline_ ABSL_GUARDED_BY(mu_);
   bool backoff_begun_ ABSL_GUARDED_BY(mu_) = false;
 
   // Retry alarm.