grpc 1.81.1 → 1.83.0

data/src/core/client_channel/client_channel.h

@@ -22,9 +22,9 @@
 #include "src/core/call/metadata.h"
 #include "src/core/client_channel/client_channel_factory.h"
 #include "src/core/client_channel/config_selector.h"
+#include "src/core/client_channel/retry_throttle.h"
 #include "src/core/client_channel/subchannel.h"
 #include "src/core/ext/filters/channel_idle/idle_filter_state.h"
-#include "src/core/filter/blackboard.h"
 #include "src/core/lib/promise/observable.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/load_balancing/lb_policy.h"
@@ -75,7 +75,9 @@ class ClientChannel : public Channel {
                         grpc_completion_queue* cq,
                         grpc_pollset_set* /*pollset_set_alternative*/,
                         Slice path, std::optional<Slice> authority,
-                        Timestamp deadline, bool registered_method) override;
+                        Timestamp deadline, bool registered_method,
+                        std::optional<absl::FunctionRef<void(Arena*)>>
+                            arena_init_function) override;
 
   void StartCall(UnstartedCallHandler unstarted_handler) override;
 
@@ -213,7 +215,7 @@ class ClientChannel : public Channel {
       ABSL_GUARDED_BY(*work_serializer_);
   RefCountedPtr<ConfigSelector> saved_config_selector_
       ABSL_GUARDED_BY(*work_serializer_);
-  RefCountedPtr<const Blackboard> blackboard_
+  RetryThrottlerChannelArgsUpdater retry_throttler_updater_
       ABSL_GUARDED_BY(*work_serializer_);
   OrphanablePtr<LoadBalancingPolicy> lb_policy_
       ABSL_GUARDED_BY(*work_serializer_);

data/src/core/client_channel/client_channel_filter.cc

@@ -465,20 +465,18 @@ class ClientChannelFilter::SubchannelWrapper final
             }
             chand_->subchannel_map_.erase(it);
           }
-          if (IsSubchannelWrapperCleanupOnOrphanEnabled()) {
-            // We need to make sure that the internal subchannel gets unreffed
-            // inside of the WorkSerializer, so that updates to the local
-            // subchannel pool are properly synchronized.  To that end, we
-            // drop our ref to the internal subchannel here.  We also cancel
-            // any watchers that were not properly cancelled, in case any of
-            // them are holding a ref to the internal subchannel.
-            for (const auto& [_, watcher] : watcher_map_) {
-              subchannel_->CancelConnectivityStateWatch(watcher);
-            }
-            watcher_map_.clear();
-            data_watchers_.clear();
-            subchannel_.reset();
+          // We need to make sure that the internal subchannel gets unreffed
+          // inside of the WorkSerializer, so that updates to the local
+          // subchannel pool are properly synchronized.  To that end, we
+          // drop our ref to the internal subchannel here.  We also cancel
+          // any watchers that were not properly cancelled, in case any of
+          // them are holding a ref to the internal subchannel.
+          for (const auto& [_, watcher] : watcher_map_) {
+            subchannel_->CancelConnectivityStateWatch(watcher);
           }
+          watcher_map_.clear();
+          data_watchers_.clear();
+          subchannel_.reset();
           WeakUnref(DEBUG_LOCATION, "subchannel map cleanup");
         });
   }
@@ -1422,11 +1420,8 @@ namespace {
 // Filter chain builder impl to inject into ConfigSelector.
 class LegacyFilterChainBuilder final : public FilterChainBuilder {
  public:
-  LegacyFilterChainBuilder(bool enable_retries, const ChannelArgs& channel_args,
-                           const Blackboard* blackboard)
-      : enable_retries_(enable_retries),
-        channel_args_(channel_args),
-        blackboard_(blackboard) {}
+  LegacyFilterChainBuilder(bool enable_retries, const ChannelArgs& channel_args)
+      : enable_retries_(enable_retries), channel_args_(channel_args) {}
 
   absl::StatusOr<RefCountedPtr<FilterChain>> Build() override {
     if (enable_retries_) {
@@ -1435,7 +1430,7 @@ class LegacyFilterChainBuilder final : public FilterChainBuilder {
       filters_.push_back({&DynamicTerminationFilter::kFilterVtable, nullptr});
     }
     RefCountedPtr<DynamicFilters> dynamic_filters =
-        DynamicFilters::Create(channel_args_, std::move(filters_), blackboard_);
+        DynamicFilters::Create(channel_args_, std::move(filters_));
     if (dynamic_filters == nullptr) {
       return absl::InternalError("error constructing dynamic filter stack");
     }
@@ -1451,7 +1446,6 @@ class LegacyFilterChainBuilder final : public FilterChainBuilder {
 
   const bool enable_retries_;
   const ChannelArgs channel_args_;
-  const Blackboard* blackboard_;
   std::vector<FilterAndConfig> filters_;
 };
 
@@ -1475,17 +1469,12 @@ void ClientChannelFilter::UpdateServiceConfigInDataPlaneLocked(
   bool enable_retries =
       !new_args.WantMinimalStack() &&
       new_args.GetBool(GRPC_ARG_ENABLE_RETRIES).value_or(true);
-  // Construct dynamic filter stack.
-  auto new_blackboard = MakeRefCounted<Blackboard>();
   if (enable_retries) {
-    RetryFilter::UpdateBlackboard(*service_config, blackboard_.get(),
-                                  new_blackboard.get());
-  }
-  LegacyFilterChainBuilder filter_chain_builder(enable_retries, new_args,
-                                                new_blackboard.get());
-  config_selector->BuildFilterChains(filter_chain_builder, blackboard_.get(),
-                                     new_blackboard.get());
-  blackboard_ = std::move(new_blackboard);
+    retry_throttler_updater_.Update(*service_config, new_args);
+  }
+  // Construct dynamic filter stack.
+  LegacyFilterChainBuilder filter_chain_builder(enable_retries, new_args);
+  config_selector->BuildFilterChains(filter_chain_builder);
   // Grab data plane lock to update service config.
   //
   // We defer unreffing the old values (and deallocating memory) until

data/src/core/client_channel/client_channel_filter.h

@@ -36,9 +36,9 @@
 #include "src/core/client_channel/client_channel_factory.h"
 #include "src/core/client_channel/config_selector.h"
 #include "src/core/client_channel/dynamic_filters.h"
+#include "src/core/client_channel/retry_throttle.h"
 #include "src/core/client_channel/subchannel.h"
 #include "src/core/client_channel/subchannel_pool_interface.h"
-#include "src/core/filter/blackboard.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -300,7 +300,7 @@ class ClientChannelFilter final {
       ABSL_GUARDED_BY(*work_serializer_);
   RefCountedPtr<ConfigSelector> saved_config_selector_
       ABSL_GUARDED_BY(*work_serializer_);
-  RefCountedPtr<const Blackboard> blackboard_
+  RetryThrottlerChannelArgsUpdater retry_throttler_updater_
       ABSL_GUARDED_BY(*work_serializer_);
   OrphanablePtr<LoadBalancingPolicy> lb_policy_
       ABSL_GUARDED_BY(*work_serializer_);

data/src/core/client_channel/client_channel_plugin.cc

@@ -32,7 +32,7 @@ namespace grpc_core {
 
 void BuildClientChannelConfiguration(CoreConfiguration::Builder* builder) {
   internal::ClientChannelServiceConfigParser::Register(builder);
-  internal::RetryServiceConfigParser::Register(builder);
+  RetryServiceConfigParser::Register(builder);
   builder->channel_init()
       ->RegisterV2Filter<ClientChannelFilter>(GRPC_CLIENT_CHANNEL)
       .Terminal();

data/src/core/client_channel/client_channel_service_config.cc

@@ -16,14 +16,12 @@
 
 #include "src/core/client_channel/client_channel_service_config.h"
 
-#include <grpc/support/port_platform.h>
-
 #include <map>
 #include <optional>
 #include <utility>
 
+#include "src/core/config/experiment_env_var.h"
 #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"
@@ -37,19 +35,13 @@ 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();
+    if (key == "connection_scaling") {
+      return IsExperimentEnvVarEnabled(
+          "GRPC_EXPERIMENTAL_MAX_CONCURRENT_STREAMS_CONNECTION_SCALING");
+    }
     return true;
   }
 };

data/src/core/client_channel/config_selector.h

@@ -27,7 +27,6 @@
 #include "src/core/call/interception_chain.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/client_channel/client_channel_internal.h"
-#include "src/core/filter/blackboard.h"
 #include "src/core/filter/filter_chain.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/resource_quota/arena.h"
@@ -63,9 +62,7 @@ class ConfigSelector : public RefCounted<ConfigSelector> {
 
   // The channel will call this when the resolver returns a new ConfigSelector
   // to initialize the filter chains that the ConfigSelector may need.
-  virtual void BuildFilterChains(FilterChainBuilder& builder,
-                                 const Blackboard* old_blackboard,
-                                 Blackboard* new_blackboard) = 0;
+  virtual void BuildFilterChains(FilterChainBuilder& builder) = 0;
 
   // Gets the configuration for the call and stores it in service config
   // call data.
@@ -105,9 +102,7 @@ class DefaultConfigSelector final : public ConfigSelector {
     return kFactory.Create();
   }
 
-  void BuildFilterChains(FilterChainBuilder& builder,
-                         const Blackboard* /*old_blackboard*/,
-                         Blackboard* /*new_blackboard*/) override {
+  void BuildFilterChains(FilterChainBuilder& builder) override {
     filter_chain_ = builder.Build();
   }
 

data/src/core/client_channel/direct_channel.cc

@@ -71,10 +71,14 @@ grpc_call* DirectChannel::CreateCall(
     grpc_call* parent_call, uint32_t propagation_mask,
     grpc_completion_queue* cq, grpc_pollset_set* /*pollset_set_alternative*/,
     Slice path, std::optional<Slice> authority, Timestamp deadline,
-    bool /*registered_method*/) {
+    bool /*registered_method*/,
+    std::optional<absl::FunctionRef<void(Arena*)>> arena_init_function) {
   auto arena = call_arena_allocator()->MakeArena();
   arena->SetContext<grpc_event_engine::experimental::EventEngine>(
       event_engine_.get());
+  if (arena_init_function.has_value()) {
+    (*arena_init_function)(arena.get());
+  }
   return MakeClientCall(parent_call, propagation_mask, cq, std::move(path),
                         std::move(authority), false, deadline,
                         compression_options(), std::move(arena), Ref());

data/src/core/client_channel/direct_channel.h

@@ -62,7 +62,9 @@ class DirectChannel final : public Channel {
                         grpc_completion_queue* cq,
                         grpc_pollset_set* pollset_set_alternative, Slice path,
                         std::optional<Slice> authority, Timestamp deadline,
-                        bool registered_method) override;
+                        bool registered_method,
+                        std::optional<absl::FunctionRef<void(Arena*)>>
+                            arena_init_function) override;
   grpc_event_engine::experimental::EventEngine* event_engine() const override {
     return event_engine_.get();
   }

data/src/core/client_channel/dynamic_filters.cc

@@ -137,10 +137,8 @@ void DynamicFilters::Call::IncrementRefCount(const DebugLocation& /*location*/,
 namespace {
 
 absl::StatusOr<RefCountedPtr<grpc_channel_stack>> CreateChannelStack(
-    const ChannelArgs& args, std::vector<FilterAndConfig> filters,
-    const Blackboard* blackboard) {
+    const ChannelArgs& args, std::vector<FilterAndConfig> filters) {
   ChannelStackBuilderImpl builder("DynamicFilters", GRPC_CLIENT_DYNAMIC, args);
-  builder.SetBlackboard(blackboard);
   for (auto& [filter, config] : filters) {
     builder.AppendFilter(filter, std::move(config));
   }
@@ -150,16 +148,15 @@ absl::StatusOr<RefCountedPtr<grpc_channel_stack>> CreateChannelStack(
 }  // namespace
 
 RefCountedPtr<DynamicFilters> DynamicFilters::Create(
-    const ChannelArgs& args, std::vector<FilterAndConfig> filters,
-    const Blackboard* blackboard) {
+    const ChannelArgs& args, std::vector<FilterAndConfig> filters) {
   // Attempt to create channel stack from requested filters.
-  auto p = CreateChannelStack(args, std::move(filters), blackboard);
+  auto p = CreateChannelStack(args, std::move(filters));
   if (!p.ok()) {
     // Channel stack creation failed with requested filters.
     // Create with lame filter instead.
     auto error = p.status();
     p = CreateChannelStack(args.Set(MakeLameClientErrorArg(&error)),
-                           {{&LameClientFilter::kFilter, nullptr}}, nullptr);
+                           {{&LameClientFilter::kFilter, nullptr}});
   }
   return MakeRefCounted<DynamicFilters>(std::move(p.value()));
 }

data/src/core/client_channel/dynamic_filters.h

@@ -23,7 +23,6 @@
 #include <utility>
 #include <vector>
 
-#include "src/core/filter/blackboard.h"
 #include "src/core/filter/filter_chain.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
@@ -90,8 +89,7 @@ class DynamicFilters final : public FilterChain {
   };
 
   static RefCountedPtr<DynamicFilters> Create(
-      const ChannelArgs& args, std::vector<FilterAndConfig> filters,
-      const Blackboard* blackboard);
+      const ChannelArgs& args, std::vector<FilterAndConfig> filters);
 
   explicit DynamicFilters(RefCountedPtr<grpc_channel_stack> channel_stack)
       : channel_stack_(std::move(channel_stack)) {}

data/src/core/client_channel/retry_filter.cc

@@ -81,9 +81,6 @@
 // TODO(roth): In subsequent PRs:
 // - implement hedging
 
-using grpc_core::internal::RetryGlobalConfig;
-using grpc_core::internal::RetryMethodConfig;
-using grpc_core::internal::RetryServiceConfigParser;
 using grpc_event_engine::experimental::EventEngine;
 
 namespace grpc_core {
@@ -92,33 +89,13 @@ namespace grpc_core {
 // RetryFilter
 //
 
-void RetryFilter::UpdateBlackboard(const ServiceConfig& service_config,
-                                   const Blackboard* old_blackboard,
-                                   Blackboard* new_blackboard) {
-  // Get retry throttling parameters from service config.
-  const auto* config = static_cast<const RetryGlobalConfig*>(
-      service_config.GetGlobalParsedConfig(
-          RetryServiceConfigParser::ParserIndex()));
-  if (config == nullptr) return;
-  // Get throttler.
-  RefCountedPtr<internal::RetryThrottler> throttler;
-  if (old_blackboard != nullptr) {
-    throttler = old_blackboard->Get<internal::RetryThrottler>("");
-  }
-  throttler = internal::RetryThrottler::Create(config->max_milli_tokens(),
-                                               config->milli_token_ratio(),
-                                               std::move(throttler));
-  new_blackboard->Set("", std::move(throttler));
-}
-
 RetryFilter::RetryFilter(const grpc_channel_element_args& args)
     : client_channel_(args.channel_args.GetObject<ClientChannelFilter>()),
       event_engine_(args.channel_args.GetObject<EventEngine>()),
       per_rpc_retry_buffer_size_(
           GetMaxPerRpcRetryBufferSize(args.channel_args)),
-      retry_throttler_(args.blackboard->Get<internal::RetryThrottler>("")),
-      service_config_parser_index_(
-          internal::RetryServiceConfigParser::ParserIndex()) {}
+      retry_throttler_(args.channel_args.GetObjectRef<RetryThrottler>()),
+      service_config_parser_index_(RetryServiceConfigParser::ParserIndex()) {}
 
 const RetryMethodConfig* RetryFilter::GetRetryPolicy(Arena* arena) {
   auto* svc_cfg_call_data = arena->GetContext<ServiceConfigCallData>();

data/src/core/client_channel/retry_filter.h

@@ -45,10 +45,6 @@ class RetryFilter final {
  public:
   static const grpc_channel_filter kFilterVtable;
 
-  static void UpdateBlackboard(const ServiceConfig& service_config,
-                               const Blackboard* old_blackboard,
-                               Blackboard* blackboard);
-
  private:
   // Old filter-stack style call implementation, in
   // retry_filter_legacy_call_data.{h,cc}
@@ -62,9 +58,9 @@ class RetryFilter final {
   // any even moderately compelling reason to do so.
   static double BackoffJitter() { return 0.2; }
 
-  const internal::RetryMethodConfig* GetRetryPolicy(Arena* arena);
+  const RetryMethodConfig* GetRetryPolicy(Arena* arena);
 
-  RefCountedPtr<internal::RetryThrottler> retry_throttler() const {
+  RefCountedPtr<RetryThrottler> retry_throttler() const {
     return retry_throttler_;
   }
 
@@ -108,7 +104,7 @@ class RetryFilter final {
   ClientChannelFilter* client_channel_;
   grpc_event_engine::experimental::EventEngine* const event_engine_;
   size_t per_rpc_retry_buffer_size_;
-  RefCountedPtr<internal::RetryThrottler> retry_throttler_;
+  RefCountedPtr<RetryThrottler> retry_throttler_;
   const size_t service_config_parser_index_;
 };
 

data/src/core/client_channel/retry_filter_legacy_call_data.cc

@@ -966,7 +966,7 @@ void GetCallStatus(
       *is_lb_drop = true;
     }
   } else {
-    *status = *md_batch->get(GrpcStatusMetadata());
+    *status = md_batch->get(GrpcStatusMetadata()).value_or(GRPC_STATUS_UNKNOWN);
   }
   *server_pushback = md_batch->get(GrpcRetryPushbackMsMetadata());
   *stream_network_state = md_batch->get(GrpcStreamNetworkState());

data/src/core/client_channel/retry_filter_legacy_call_data.h

@@ -369,8 +369,8 @@ class RetryFilter::LegacyCallData final {
 
   RetryFilter* chand_;
   grpc_polling_entity* pollent_;
-  RefCountedPtr<internal::RetryThrottler> retry_throttler_;
-  const internal::RetryMethodConfig* retry_policy_ = nullptr;
+  RefCountedPtr<RetryThrottler> retry_throttler_;
+  const RetryMethodConfig* retry_policy_ = nullptr;
   BackOff retry_backoff_;
 
   Timestamp deadline_;

data/src/core/client_channel/retry_interceptor.cc

@@ -35,8 +35,8 @@ size_t GetMaxPerRpcRetryBufferSize(const ChannelArgs& args) {
 
 namespace retry_detail {
 
-RetryState::RetryState(const internal::RetryMethodConfig* retry_policy,
-                       RefCountedPtr<internal::RetryThrottler> retry_throttler)
+RetryState::RetryState(const RetryMethodConfig* retry_policy,
+                       RefCountedPtr<RetryThrottler> retry_throttler)
     : retry_policy_(retry_policy),
       retry_throttler_(std::move(retry_throttler)),
       retry_backoff_(
@@ -134,38 +134,10 @@ std::optional<Duration> RetryState::ShouldRetry(
 ////////////////////////////////////////////////////////////////////////////////
 // RetryInterceptor
 
-absl::StatusOr<RefCountedPtr<RetryInterceptor>> RetryInterceptor::Create(
-    const ChannelArgs& args, const FilterArgs& filter_args) {
-  auto retry_throttler = filter_args.GetState<internal::RetryThrottler>("");
-  return MakeRefCounted<RetryInterceptor>(args, std::move(retry_throttler));
-}
-
-void RetryInterceptor::UpdateBlackboard(const ServiceConfig& service_config,
-                                        const Blackboard* old_blackboard,
-                                        Blackboard* new_blackboard) {
-  const auto* config = static_cast<const internal::RetryGlobalConfig*>(
-      service_config.GetGlobalParsedConfig(
-          internal::RetryServiceConfigParser::ParserIndex()));
-  if (config == nullptr) return;
-  // Get existing throttle state.
-  RefCountedPtr<internal::RetryThrottler> throttler;
-  if (old_blackboard != nullptr) {
-    throttler = old_blackboard->Get<internal::RetryThrottler>("");
-  }
-  throttler = internal::RetryThrottler::Create(config->max_milli_tokens(),
-                                               config->milli_token_ratio(),
-                                               std::move(throttler));
-  CHECK_NE(new_blackboard, nullptr);
-  new_blackboard->Set("", std::move(throttler));
-}
-
-RetryInterceptor::RetryInterceptor(
-    const ChannelArgs& args,
-    RefCountedPtr<internal::RetryThrottler> retry_throttler)
+RetryInterceptor::RetryInterceptor(const ChannelArgs& args)
     : per_rpc_retry_buffer_size_(GetMaxPerRpcRetryBufferSize(args)),
-      service_config_parser_index_(
-          internal::RetryServiceConfigParser::ParserIndex()),
-      retry_throttler_(std::move(retry_throttler)) {}
+      service_config_parser_index_(RetryServiceConfigParser::ParserIndex()),
+      retry_throttler_(args.GetObjectRef<RetryThrottler>()) {}
 
 void RetryInterceptor::InterceptCall(
     UnstartedCallHandler unstarted_call_handler) {
@@ -177,10 +149,10 @@ void RetryInterceptor::InterceptCall(
   call->Start();
 }
 
-const internal::RetryMethodConfig* RetryInterceptor::GetRetryPolicy() {
+const RetryMethodConfig* RetryInterceptor::GetRetryPolicy() {
   auto* svc_cfg_call_data = MaybeGetContext<ServiceConfigCallData>();
   if (svc_cfg_call_data == nullptr) return nullptr;
-  return static_cast<const internal::RetryMethodConfig*>(
+  return static_cast<const RetryMethodConfig*>(
       svc_cfg_call_data->GetMethodParsedConfig(service_config_parser_index_));
 }
 

data/src/core/client_channel/retry_interceptor.h

@@ -29,8 +29,8 @@ namespace retry_detail {
 
 class RetryState {
  public:
-  RetryState(const internal::RetryMethodConfig* retry_policy,
-             RefCountedPtr<internal::RetryThrottler> retry_throttler);
+  RetryState(const RetryMethodConfig* retry_policy,
+             RefCountedPtr<RetryThrottler> retry_throttler);
 
   // if nullopt --> commit & don't retry
   // if duration --> retry after duration
@@ -50,8 +50,8 @@ class RetryState {
   }
 
  private:
-  const internal::RetryMethodConfig* const retry_policy_;
-  RefCountedPtr<internal::RetryThrottler> retry_throttler_;
+  const RetryMethodConfig* const retry_policy_;
+  RefCountedPtr<RetryThrottler> retry_throttler_;
   int num_attempts_completed_ = 0;
   BackOff retry_backoff_;
 };
@@ -60,17 +60,14 @@ class RetryState {
 
 class RetryInterceptor : public Interceptor {
  public:
-  RetryInterceptor(const ChannelArgs& args,
-                   RefCountedPtr<internal::RetryThrottler> retry_throttler);
-
   static absl::StatusOr<RefCountedPtr<RetryInterceptor>> Create(
-      const ChannelArgs& args, const FilterArgs& filter_args);
+      const ChannelArgs& args, const FilterArgs& /*filter_args*/) {
+    return MakeRefCounted<RetryInterceptor>(args);
+  }
 
-  void Orphaned() override {}
+  explicit RetryInterceptor(const ChannelArgs& args);
 
-  static void UpdateBlackboard(const ServiceConfig& service_config,
-                               const Blackboard* old_blackboard,
-                               Blackboard* new_blackboard);
+  void Orphaned() override {}
 
  protected:
   void InterceptCall(UnstartedCallHandler unstarted_call_handler) override;
@@ -146,11 +143,11 @@ class RetryInterceptor : public Interceptor {
     bool committed_ = false;
   };
 
-  const internal::RetryMethodConfig* GetRetryPolicy();
+  const RetryMethodConfig* GetRetryPolicy();
 
   const size_t per_rpc_retry_buffer_size_;
   const size_t service_config_parser_index_;
-  const RefCountedPtr<internal::RetryThrottler> retry_throttler_;
+  const RefCountedPtr<RetryThrottler> retry_throttler_;
 };
 
 }  // namespace grpc_core

data/src/core/client_channel/retry_service_config.cc

@@ -39,7 +39,6 @@
 #define MAX_MAX_RETRY_ATTEMPTS 5
 
 namespace grpc_core {
-namespace internal {
 
 //
 // RetryGlobalConfig
@@ -276,5 +275,4 @@ RetryServiceConfigParser::ParsePerMethodParams(const ChannelArgs& args,
   return std::move(method_params.retry_policy);
 }
 
-}  // namespace internal
 }  // namespace grpc_core

data/src/core/client_channel/retry_service_config.h

@@ -36,7 +36,6 @@
 #include "absl/strings/string_view.h"
 
 namespace grpc_core {
-namespace internal {
 
 class RetryGlobalConfig final : public ServiceConfigParser::ParsedConfig {
  public:
@@ -110,7 +109,6 @@ class RetryServiceConfigParser final : public ServiceConfigParser::Parser {
   static absl::string_view parser_name() { return "retry"; }
 };
 
-}  // namespace internal
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_CLIENT_CHANNEL_RETRY_SERVICE_CONFIG_H

data/src/core/client_channel/retry_throttle.cc

@@ -22,10 +22,10 @@
 #include <cstdint>
 #include <limits>
 
+#include "src/core/client_channel/retry_service_config.h"
 #include "src/core/util/useful.h"
 
 namespace grpc_core {
-namespace internal {
 
 namespace {
 
@@ -71,11 +71,6 @@ RefCountedPtr<RetryThrottler> RetryThrottler::Create(
   return throttle_data;
 }
 
-UniqueTypeName RetryThrottler::Type() {
-  static UniqueTypeName::Factory factory("retry_throttle");
-  return factory.Create();
-}
-
 RetryThrottler::RetryThrottler(uintptr_t max_milli_tokens,
                                uintptr_t milli_token_ratio,
                                uintptr_t milli_tokens)
@@ -130,5 +125,22 @@ void RetryThrottler::RecordSuccess() {
                                  std::numeric_limits<intptr_t>::max())));
 }
 
-}  // namespace internal
+void RetryThrottlerChannelArgsUpdater::Update(
+    const ServiceConfig& service_config, ChannelArgs& args) {
+  // Get retry throttling parameters from service config.
+  const auto* config = static_cast<const RetryGlobalConfig*>(
+      service_config.GetGlobalParsedConfig(
+          RetryServiceConfigParser::ParserIndex()));
+  if (config == nullptr) {
+    throttler_.reset();  // No throttling config.
+    return;
+  }
+  // Create a new throttler that replaces the current throttler and add
+  // it to channel args.
+  throttler_ = RetryThrottler::Create(config->max_milli_tokens(),
+                                      config->milli_token_ratio(),
+                                      std::move(throttler_));
+  args = args.SetObject(throttler_);
+}
+
 }  // namespace grpc_core