grpc 1.62.3 → 1.63.0

data/src/core/client_channel/client_channel_filter.cc

@@ -49,7 +49,6 @@
 #include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
 
-#include "src/core/client_channel/backend_metric.h"
 #include "src/core/client_channel/backup_poller.h"
 #include "src/core/client_channel/client_channel_channelz.h"
 #include "src/core/client_channel/client_channel_internal.h"
@@ -92,20 +91,20 @@
 #include "src/core/lib/promise/promise.h"
 #include "src/core/lib/promise/try_seq.h"
 #include "src/core/lib/security/credentials/credentials.h"
-#include "src/core/service_config/service_config_call_data.h"
-#include "src/core/service_config/service_config_impl.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/call.h"
-#include "src/core/lib/surface/channel.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/error_utils.h"
 #include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/load_balancing/backend_metric_parser.h"
 #include "src/core/load_balancing/child_policy_handler.h"
 #include "src/core/load_balancing/lb_policy_registry.h"
 #include "src/core/load_balancing/subchannel_interface.h"
 #include "src/core/resolver/endpoint_addresses.h"
 #include "src/core/resolver/resolver_registry.h"
+#include "src/core/service_config/service_config_call_data.h"
+#include "src/core/service_config/service_config_impl.h"
 
 //
 // Client channel filter
@@ -192,7 +191,7 @@ class ClientChannelFilter::CallData {
   RefCountedPtr<DynamicFilters> dynamic_filters_;
 };
 
-class ClientChannelFilter::FilterBasedCallData
+class ClientChannelFilter::FilterBasedCallData final
     : public ClientChannelFilter::CallData {
  public:
   static grpc_error_handle Init(grpc_call_element* elem,
@@ -312,7 +311,7 @@ class ClientChannelFilter::FilterBasedCallData
   grpc_error_handle cancel_error_;
 };
 
-class ClientChannelFilter::PromiseBasedCallData
+class ClientChannelFilter::PromiseBasedCallData final
     : public ClientChannelFilter::CallData {
  public:
   explicit PromiseBasedCallData(ClientChannelFilter* chand) : chand_(chand) {}
@@ -452,7 +451,7 @@ ClientChannelServiceConfigCallData* GetServiceConfigCallData(
       context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value);
 }
 
-class DynamicTerminationFilter {
+class DynamicTerminationFilter final {
  public:
   class CallData;
 
@@ -497,7 +496,7 @@ class DynamicTerminationFilter {
   ClientChannelFilter* chand_;
 };
 
-class DynamicTerminationFilter::CallData {
+class DynamicTerminationFilter::CallData final {
  public:
   static grpc_error_handle Init(grpc_call_element* elem,
                                 const grpc_call_element_args* args) {
@@ -594,7 +593,7 @@ const grpc_channel_filter DynamicTerminationFilter::kFilterVtable = {
 // ClientChannelFilter::ResolverResultHandler
 //
 
-class ClientChannelFilter::ResolverResultHandler
+class ClientChannelFilter::ResolverResultHandler final
     : public Resolver::ResultHandler {
  public:
   explicit ResolverResultHandler(ClientChannelFilter* chand) : chand_(chand) {
@@ -629,7 +628,8 @@ class ClientChannelFilter::ResolverResultHandler
 // underlying subchannel is shared between channels, this wrapper will only
 // be used within one channel, so it will always be synchronized by the
 // control plane work_serializer.
-class ClientChannelFilter::SubchannelWrapper : public SubchannelInterface {
+class ClientChannelFilter::SubchannelWrapper final
+    : public SubchannelInterface {
  public:
   SubchannelWrapper(ClientChannelFilter* chand,
                     RefCountedPtr<Subchannel> subchannel)
@@ -685,7 +685,7 @@ class ClientChannelFilter::SubchannelWrapper : public SubchannelInterface {
     GRPC_CHANNEL_STACK_UNREF(chand_->owning_stack_, "SubchannelWrapper");
   }
 
-  void Orphan() override {
+  void Orphaned() override {
     if (!IsWorkSerializerDispatchEnabled()) return;
     // Make sure we clean up the channel's subchannel maps inside the
     // WorkSerializer.
@@ -772,7 +772,8 @@ class ClientChannelFilter::SubchannelWrapper : public SubchannelInterface {
   // This class handles things like hopping into the WorkSerializer
   // before passing notifications to the LB policy and propagating
   // keepalive information betwen subchannels.
-  class WatcherWrapper : public Subchannel::ConnectivityStateWatcherInterface {
+  class WatcherWrapper final
+      : public Subchannel::ConnectivityStateWatcherInterface {
    public:
     WatcherWrapper(
         std::unique_ptr<SubchannelInterface::ConnectivityStateWatcherInterface>
@@ -1025,7 +1026,7 @@ void ClientChannelFilter::ExternalConnectivityWatcher::RemoveWatcherLocked() {
 // ClientChannelFilter::ConnectivityWatcherAdder
 //
 
-class ClientChannelFilter::ConnectivityWatcherAdder {
+class ClientChannelFilter::ConnectivityWatcherAdder final {
  public:
   ConnectivityWatcherAdder(
       ClientChannelFilter* chand, grpc_connectivity_state initial_state,
@@ -1058,7 +1059,7 @@ class ClientChannelFilter::ConnectivityWatcherAdder {
 // ClientChannelFilter::ConnectivityWatcherRemover
 //
 
-class ClientChannelFilter::ConnectivityWatcherRemover {
+class ClientChannelFilter::ConnectivityWatcherRemover final {
  public:
   ConnectivityWatcherRemover(ClientChannelFilter* chand,
                              AsyncConnectivityStateWatcherInterface* watcher)
@@ -1088,7 +1089,7 @@ class ClientChannelFilter::ConnectivityWatcherRemover {
 // ClientChannelFilter::ClientChannelControlHelper
 //
 
-class ClientChannelFilter::ClientChannelControlHelper
+class ClientChannelFilter::ClientChannelControlHelper final
     : public LoadBalancingPolicy::ChannelControlHelper {
  public:
   explicit ClientChannelControlHelper(ClientChannelFilter* chand)
@@ -1148,6 +1149,8 @@ class ClientChannelFilter::ClientChannelControlHelper
     chand_->resolver_->RequestReresolutionLocked();
   }
 
+  absl::string_view GetTarget() override { return chand_->target_uri_; }
+
   absl::string_view GetAuthority() override {
     return chand_->default_authority_;
   }
@@ -1166,6 +1169,10 @@ class ClientChannelFilter::ClientChannelControlHelper
     return chand_->owning_stack_->EventEngine();
   }
 
+  GlobalStatsPluginRegistry::StatsPluginGroup& GetStatsPluginGroup() override {
+    return *chand_->owning_stack_->stats_plugin_group;
+  }
+
   void AddTraceEvent(TraceSeverity severity, absl::string_view message) override
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*chand_->work_serializer_) {
     if (chand_->resolver_ == nullptr) return;  // Shutting down.
@@ -1191,16 +1198,6 @@ class ClientChannelFilter::ClientChannelControlHelper
 // ClientChannelFilter implementation
 //
 
-ClientChannelFilter* ClientChannelFilter::GetFromChannel(Channel* channel) {
-  grpc_channel_element* elem =
-      grpc_channel_stack_last_element(channel->channel_stack());
-  if (elem->filter != &kFilterVtableWithPromises &&
-      elem->filter != &kFilterVtableWithoutPromises) {
-    return nullptr;
-  }
-  return static_cast<ClientChannelFilter*>(elem->channel_data);
-}
-
 grpc_error_handle ClientChannelFilter::Init(grpc_channel_element* elem,
                                             grpc_channel_element_args* args) {
   GPR_ASSERT(args->is_last);
@@ -1270,18 +1267,19 @@ ClientChannelFilter::ClientChannelFilter(grpc_channel_element_args* args,
   }
   default_service_config_ = std::move(*service_config);
   // Get URI to resolve, using proxy mapper if needed.
-  absl::optional<std::string> server_uri =
+  absl::optional<std::string> target_uri =
       channel_args_.GetOwnedString(GRPC_ARG_SERVER_URI);
-  if (!server_uri.has_value()) {
+  if (!target_uri.has_value()) {
     *error = GRPC_ERROR_CREATE(
         "target URI channel arg missing or wrong type in client channel "
         "filter");
     return;
   }
+  target_uri_ = std::move(*target_uri);
   uri_to_resolve_ = CoreConfiguration::Get()
                         .proxy_mapper_registry()
-                        .MapName(*server_uri, &channel_args_)
-                        .value_or(*server_uri);
+                        .MapName(target_uri_, &channel_args_)
+                        .value_or(target_uri_);
   // Make sure the URI to resolve is valid, so that we know that
   // resolver creation will succeed later.
   if (!CoreConfiguration::Get().resolver_registry().IsValidTarget(
@@ -1306,7 +1304,7 @@ ClientChannelFilter::ClientChannelFilter(grpc_channel_element_args* args,
   if (!default_authority.has_value()) {
     default_authority_ =
         CoreConfiguration::Get().resolver_registry().GetDefaultAuthority(
-            *server_uri);
+            target_uri_);
   } else {
     default_authority_ = std::move(*default_authority);
   }
@@ -1344,6 +1342,7 @@ ClientChannelFilter::CreateLoadBalancedCall(
     const grpc_call_element_args& args, grpc_polling_entity* pollent,
     grpc_closure* on_call_destruction_complete,
     absl::AnyInvocable<void()> on_commit, bool is_transparent_retry) {
+  promise_detail::Context<Arena> arena_ctx(args.arena);
   return OrphanablePtr<FilterBasedLoadBalancedCall>(
       args.arena->New<FilterBasedLoadBalancedCall>(
           this, args, pollent, on_call_destruction_complete,
@@ -2481,7 +2480,8 @@ void ClientChannelFilter::FilterBasedCallData::PendingBatchesResume() {
 
 // A class to handle the call combiner cancellation callback for a
 // queued pick.
-class ClientChannelFilter::FilterBasedCallData::ResolverQueuedCallCanceller {
+class ClientChannelFilter::FilterBasedCallData::ResolverQueuedCallCanceller
+    final {
  public:
   explicit ResolverQueuedCallCanceller(FilterBasedCallData* calld)
       : calld_(calld) {
@@ -2602,7 +2602,7 @@ void ClientChannelFilter::FilterBasedCallData::
 // ClientChannelFilter::LoadBalancedCall::LbCallState
 //
 
-class ClientChannelFilter::LoadBalancedCall::LbCallState
+class ClientChannelFilter::LoadBalancedCall::LbCallState final
     : public ClientChannelLbCallState {
  public:
   explicit LbCallState(LoadBalancedCall* lb_call) : lb_call_(lb_call) {}
@@ -2624,7 +2624,7 @@ class ClientChannelFilter::LoadBalancedCall::LbCallState
 // ClientChannelFilter::LoadBalancedCall::Metadata
 //
 
-class ClientChannelFilter::LoadBalancedCall::Metadata
+class ClientChannelFilter::LoadBalancedCall::Metadata final
     : public LoadBalancingPolicy::MetadataInterface {
  public:
   explicit Metadata(grpc_metadata_batch* batch) : batch_(batch) {}
@@ -2664,7 +2664,7 @@ class ClientChannelFilter::LoadBalancedCall::Metadata
   }
 
  private:
-  class Encoder {
+  class Encoder final {
    public:
     void Encode(const Slice& key, const Slice& value) {
       out_.emplace_back(std::string(key.as_string_view()),
@@ -2717,7 +2717,7 @@ ClientChannelFilter::LoadBalancedCall::LbCallState::GetCallAttemptTracer()
 // ClientChannelFilter::LoadBalancedCall::BackendMetricAccessor
 //
 
-class ClientChannelFilter::LoadBalancedCall::BackendMetricAccessor
+class ClientChannelFilter::LoadBalancedCall::BackendMetricAccessor final
     : public LoadBalancingPolicy::BackendMetricAccessor {
  public:
   BackendMetricAccessor(LoadBalancedCall* lb_call,
@@ -2738,7 +2738,7 @@ class ClientChannelFilter::LoadBalancedCall::BackendMetricAccessor
   }
 
  private:
-  class BackendMetricAllocator : public BackendMetricAllocatorInterface {
+  class BackendMetricAllocator final : public BackendMetricAllocatorInterface {
    public:
     explicit BackendMetricAllocator(Arena* arena) : arena_(arena) {}
 
@@ -2898,6 +2898,15 @@ ClientChannelFilter::LoadBalancedCall::PickSubchannel(bool was_queued) {
     set_picker(chand_->picker_);
   }
   while (true) {
+    // TODO(roth): Fix race condition in channel_idle filter and any
+    // other possible causes of this.
+    if (pickers.back() == nullptr) {
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
+        gpr_log(GPR_ERROR, "chand=%p lb_call=%p: picker is null, failing call",
+                chand_, this);
+      }
+      return absl::InternalError("picker is null -- shouldn't happen");
+    }
     // Do pick.
     if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_lb_call_trace)) {
       gpr_log(GPR_INFO, "chand=%p lb_call=%p: performing pick with picker=%p",
@@ -3384,7 +3393,8 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
 // because there may be multiple LB picks happening in parallel.
 // Instead, we will probably need to maintain a list in the CallData
 // object of pending LB picks to be cancelled when the closure runs.
-class ClientChannelFilter::FilterBasedLoadBalancedCall::LbQueuedCallCanceller {
+class ClientChannelFilter::FilterBasedLoadBalancedCall::LbQueuedCallCanceller
+    final {
  public:
   explicit LbQueuedCallCanceller(
       RefCountedPtr<FilterBasedLoadBalancedCall> lb_call)
@@ -3529,7 +3539,7 @@ ClientChannelFilter::PromiseBasedLoadBalancedCall::MakeCallPromise(
         [this]() {
           // TODO(roth): Change CallTracer API to not pass metadata
           // batch to this method, since the batch is always empty.
-          grpc_metadata_batch metadata(GetContext<Arena>());
+          grpc_metadata_batch metadata;
           call_attempt_tracer()->RecordSendTrailingMetadata(&metadata);
         });
   }

data/src/core/client_channel/client_channel_filter.h

@@ -65,7 +65,6 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/service_config/service_config.h"
 #include "src/core/lib/slice/slice.h"
-#include "src/core/lib/surface/channel.h"
 #include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
@@ -102,7 +101,7 @@
 
 namespace grpc_core {
 
-class ClientChannelFilter {
+class ClientChannelFilter final {
  public:
   static const grpc_channel_filter kFilterVtableWithPromises;
   static const grpc_channel_filter kFilterVtableWithoutPromises;
@@ -115,10 +114,6 @@ class ClientChannelFilter {
   struct RawPointerChannelArgTag {};
   static absl::string_view ChannelArgName() { return GRPC_ARG_CLIENT_CHANNEL; }
 
-  // Returns the ClientChannelFilter object from channel, or null if channel
-  // is not a client channel.
-  static ClientChannelFilter* GetFromChannel(Channel* channel);
-
   static ArenaPromise<ServerMetadataHandle> MakeCallPromise(
       grpc_channel_element* elem, CallArgs call_args,
       NextPromiseFactory next_promise_factory);
@@ -149,11 +144,6 @@ class ClientChannelFilter {
         this, on_complete, /*cancel=*/true);
   }
 
-  int NumExternalConnectivityWatchers() const {
-    MutexLock lock(&external_watchers_mu_);
-    return static_cast<int>(external_watchers_.size());
-  }
-
   // Starts and stops a connectivity watch.  The watcher will be initially
   // notified as soon as the state changes from initial_state and then on
   // every subsequent state change until either the watch is stopped or
@@ -194,7 +184,8 @@ class ClientChannelFilter {
 
   // Represents a pending connectivity callback from an external caller
   // via grpc_client_channel_watch_connectivity_state().
-  class ExternalConnectivityWatcher : public ConnectivityStateWatcherInterface {
+  class ExternalConnectivityWatcher final
+      : public ConnectivityStateWatcherInterface {
    public:
     ExternalConnectivityWatcher(ClientChannelFilter* chand,
                                 grpc_polling_entity pollent,
@@ -300,6 +291,7 @@ class ClientChannelFilter {
   grpc_channel_stack* owning_stack_;
   ClientChannelFactory* client_channel_factory_;
   RefCountedPtr<ServiceConfig> default_service_config_;
+  std::string target_uri_;
   std::string uri_to_resolve_;
   std::string default_authority_;
   channelz::ChannelNode* channelz_node_;
@@ -478,7 +470,7 @@ class ClientChannelFilter::LoadBalancedCall
   grpc_call_context_element* const call_context_;
 };
 
-class ClientChannelFilter::FilterBasedLoadBalancedCall
+class ClientChannelFilter::FilterBasedLoadBalancedCall final
     : public ClientChannelFilter::LoadBalancedCall {
  public:
   // If on_call_destruction_complete is non-null, then it will be
@@ -604,7 +596,7 @@ class ClientChannelFilter::FilterBasedLoadBalancedCall
   grpc_transport_stream_op_batch* pending_batches_[MAX_PENDING_BATCHES] = {};
 };
 
-class ClientChannelFilter::PromiseBasedLoadBalancedCall
+class ClientChannelFilter::PromiseBasedLoadBalancedCall final
     : public ClientChannelFilter::LoadBalancedCall {
  public:
   PromiseBasedLoadBalancedCall(ClientChannelFilter* chand,

data/src/core/client_channel/client_channel_internal.h

@@ -54,7 +54,7 @@ class ClientChannelLbCallState : public LoadBalancingPolicy::CallState {
 };
 
 // Internal type for ServiceConfigCallData.  Handles call commits.
-class ClientChannelServiceConfigCallData : public ServiceConfigCallData {
+class ClientChannelServiceConfigCallData final : public ServiceConfigCallData {
  public:
   ClientChannelServiceConfigCallData(Arena* arena,
                                      grpc_call_context_element* call_context)

data/src/core/client_channel/client_channel_service_config.h

@@ -41,7 +41,7 @@
 namespace grpc_core {
 namespace internal {
 
-class ClientChannelGlobalParsedConfig
+class ClientChannelGlobalParsedConfig final
     : public ServiceConfigParser::ParsedConfig {
  public:
   RefCountedPtr<LoadBalancingPolicy::Config> parsed_lb_config() const {
@@ -72,7 +72,7 @@ class ClientChannelGlobalParsedConfig
   HealthCheckConfig health_check_config_;
 };
 
-class ClientChannelMethodParsedConfig
+class ClientChannelMethodParsedConfig final
     : public ServiceConfigParser::ParsedConfig {
  public:
   Duration timeout() const { return timeout_; }
@@ -86,7 +86,8 @@ class ClientChannelMethodParsedConfig
   absl::optional<bool> wait_for_ready_;
 };
 
-class ClientChannelServiceConfigParser : public ServiceConfigParser::Parser {
+class ClientChannelServiceConfigParser final
+    : public ServiceConfigParser::Parser {
  public:
   absl::string_view name() const override { return parser_name(); }
 

data/src/core/client_channel/config_selector.h

@@ -90,7 +90,7 @@ class ConfigSelector : public RefCounted<ConfigSelector> {
 };
 
 // Default ConfigSelector that gets the MethodConfig from the service config.
-class DefaultConfigSelector : public ConfigSelector {
+class DefaultConfigSelector final : public ConfigSelector {
  public:
   explicit DefaultConfigSelector(RefCountedPtr<ServiceConfig> service_config)
       : service_config_(std::move(service_config)) {

data/src/core/client_channel/dynamic_filters.h

@@ -42,7 +42,7 @@
 
 namespace grpc_core {
 
-class DynamicFilters : public RefCounted<DynamicFilters> {
+class DynamicFilters final : public RefCounted<DynamicFilters> {
  public:
   // Implements the interface of RefCounted<>.
   class Call {

data/src/core/client_channel/http_proxy_mapper.cc

@@ -30,6 +30,7 @@
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/ascii.h"
+#include "absl/strings/escaping.h"
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
@@ -50,7 +51,6 @@
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/resolve_address.h"
-#include "src/core/lib/slice/b64.h"
 #include "src/core/lib/transport/http_connect_handshaker.h"
 #include "src/core/lib/uri/uri_parser.h"
 
@@ -258,11 +258,10 @@ absl::optional<std::string> HttpProxyMapper::MapName(
                     MaybeAddDefaultPort(absl::StripPrefix(uri->path(), "/")));
   if (user_cred.has_value()) {
     // Use base64 encoding for user credentials as stated in RFC 7617
-    auto encoded_user_cred = UniquePtr<char>(
-        grpc_base64_encode(user_cred->data(), user_cred->length(), 0, 0));
+    std::string encoded_user_cred = absl::Base64Escape(*user_cred);
     *args = args->Set(
         GRPC_ARG_HTTP_CONNECT_HEADERS,
-        absl::StrCat("Proxy-Authorization:Basic ", encoded_user_cred.get()));
+        absl::StrCat("Proxy-Authorization:Basic ", encoded_user_cred));
   }
   return name_to_resolve;
 }

data/src/core/client_channel/http_proxy_mapper.h

@@ -33,7 +33,7 @@
 
 namespace grpc_core {
 
-class HttpProxyMapper : public ProxyMapperInterface {
+class HttpProxyMapper final : public ProxyMapperInterface {
  public:
   static constexpr char const* kAddressProxyEnvVar = "GRPC_ADDRESS_HTTP_PROXY";
   static constexpr char const* kAddressProxyEnabledAddressesEnvVar =

data/src/core/client_channel/retry_filter.h

@@ -48,7 +48,7 @@ extern grpc_core::TraceFlag grpc_retry_trace;
 
 namespace grpc_core {
 
-class RetryFilter {
+class RetryFilter final {
  public:
   static const grpc_channel_filter kVtable;
 

data/src/core/client_channel/retry_filter_legacy_call_data.cc

@@ -72,7 +72,7 @@ namespace grpc_core {
 // those refs are not released until the LB call stack is destroyed.
 // When this object is destroyed, it will invoke the
 // on_call_stack_destruction closure from the surface.
-class RetryFilter::LegacyCallData::CallStackDestructionBarrier
+class RetryFilter::LegacyCallData::CallStackDestructionBarrier final
     : public RefCounted<CallStackDestructionBarrier, PolymorphicRefCount,
                         UnrefCallDtor> {
  public:

data/src/core/client_channel/retry_filter_legacy_call_data.h

@@ -54,7 +54,7 @@
 
 namespace grpc_core {
 
-class RetryFilter::LegacyCallData {
+class RetryFilter::LegacyCallData final {
  public:
   static grpc_error_handle Init(grpc_call_element* elem,
                                 const grpc_call_element_args* args);
@@ -78,7 +78,7 @@ class RetryFilter::LegacyCallData {
   };
 
   // State associated with each call attempt.
-  class CallAttempt : public RefCounted<CallAttempt> {
+  class CallAttempt final : public RefCounted<CallAttempt> {
    public:
     CallAttempt(LegacyCallData* calld, bool is_transparent_retry);
     ~CallAttempt() override;
@@ -102,7 +102,7 @@ class RetryFilter::LegacyCallData {
     // structures needed to populate the ops in the batch.
     // We allocate one struct on the arena for each attempt at starting a
     // batch on a given LB call.
-    class BatchData
+    class BatchData final
         : public RefCounted<BatchData, PolymorphicRefCount, UnrefCallDtor> {
      public:
       BatchData(RefCountedPtr<CallAttempt> call_attempt, int refcount,
@@ -266,11 +266,11 @@ class RetryFilter::LegacyCallData {
     // BatchData.batch.payload points to this.
     grpc_transport_stream_op_batch_payload batch_payload_;
     // For send_initial_metadata.
-    grpc_metadata_batch send_initial_metadata_{calld_->arena_};
+    grpc_metadata_batch send_initial_metadata_;
     // For send_trailing_metadata.
-    grpc_metadata_batch send_trailing_metadata_{calld_->arena_};
+    grpc_metadata_batch send_trailing_metadata_;
     // For intercepting recv_initial_metadata.
-    grpc_metadata_batch recv_initial_metadata_{calld_->arena_};
+    grpc_metadata_batch recv_initial_metadata_;
     grpc_closure recv_initial_metadata_ready_;
     bool trailing_metadata_available_ = false;
     // For intercepting recv_message.
@@ -278,7 +278,7 @@ class RetryFilter::LegacyCallData {
     absl::optional<SliceBuffer> recv_message_;
     uint32_t recv_message_flags_;
     // For intercepting recv_trailing_metadata.
-    grpc_metadata_batch recv_trailing_metadata_{calld_->arena_};
+    grpc_metadata_batch recv_trailing_metadata_;
     grpc_transport_stream_stats collect_stats_;
     grpc_closure recv_trailing_metadata_ready_;
     // These fields indicate which ops have been started and completed on
@@ -420,7 +420,7 @@ class RetryFilter::LegacyCallData {
   // Cached data for retrying send ops.
   // send_initial_metadata
   bool seen_send_initial_metadata_ = false;
-  grpc_metadata_batch send_initial_metadata_{arena_};
+  grpc_metadata_batch send_initial_metadata_;
   // send_message
   // When we get a send_message op, we replace the original byte stream
   // with a CachingByteStream that caches the slices to a local buffer for
@@ -435,7 +435,7 @@ class RetryFilter::LegacyCallData {
   absl::InlinedVector<CachedSendMessage, 3> send_messages_;
   // send_trailing_metadata
   bool seen_send_trailing_metadata_ = false;
-  grpc_metadata_batch send_trailing_metadata_{arena_};
+  grpc_metadata_batch send_trailing_metadata_;
 };
 
 }  // namespace grpc_core

data/src/core/client_channel/retry_service_config.h

@@ -40,7 +40,7 @@
 namespace grpc_core {
 namespace internal {
 
-class RetryGlobalConfig : public ServiceConfigParser::ParsedConfig {
+class RetryGlobalConfig final : public ServiceConfigParser::ParsedConfig {
  public:
   uintptr_t max_milli_tokens() const { return max_milli_tokens_; }
   uintptr_t milli_token_ratio() const { return milli_token_ratio_; }
@@ -54,7 +54,7 @@ class RetryGlobalConfig : public ServiceConfigParser::ParsedConfig {
   uintptr_t milli_token_ratio_ = 0;
 };
 
-class RetryMethodConfig : public ServiceConfigParser::ParsedConfig {
+class RetryMethodConfig final : public ServiceConfigParser::ParsedConfig {
  public:
   int max_attempts() const { return max_attempts_; }
   Duration initial_backoff() const { return initial_backoff_; }
@@ -80,7 +80,7 @@ class RetryMethodConfig : public ServiceConfigParser::ParsedConfig {
   absl::optional<Duration> per_attempt_recv_timeout_;
 };
 
-class RetryServiceConfigParser : public ServiceConfigParser::Parser {
+class RetryServiceConfigParser final : public ServiceConfigParser::Parser {
  public:
   absl::string_view name() const override { return parser_name(); }
 

data/src/core/client_channel/retry_throttle.h

@@ -38,7 +38,8 @@ namespace grpc_core {
 namespace internal {
 
 /// Tracks retry throttling data for an individual server name.
-class ServerRetryThrottleData : public RefCounted<ServerRetryThrottleData> {
+class ServerRetryThrottleData final
+    : public RefCounted<ServerRetryThrottleData> {
  public:
   ServerRetryThrottleData(uintptr_t max_milli_tokens,
                           uintptr_t milli_token_ratio,
@@ -68,7 +69,7 @@ class ServerRetryThrottleData : public RefCounted<ServerRetryThrottleData> {
 };
 
 /// Global map of server name to retry throttle data.
-class ServerRetryThrottleMap {
+class ServerRetryThrottleMap final {
  public:
   static ServerRetryThrottleMap* Get();
 

data/src/core/client_channel/subchannel.cc

@@ -328,7 +328,7 @@ void SubchannelCall::IncrementRefCount(const DebugLocation& /*location*/,
 // Subchannel::ConnectedSubchannelStateWatcher
 //
 
-class Subchannel::ConnectedSubchannelStateWatcher
+class Subchannel::ConnectedSubchannelStateWatcher final
     : public AsyncConnectivityStateWatcherInterface {
  public:
   // Must be instantiated while holding c->mu.
@@ -619,7 +619,7 @@ void Subchannel::ResetBackoff() {
   work_serializer_.DrainQueue();
 }
 
-void Subchannel::Orphan() {
+void Subchannel::Orphaned() {
   // The subchannel_pool is only used once here in this subchannel, so the
   // access can be outside of the lock.
   if (subchannel_pool_ != nullptr) {

data/src/core/client_channel/subchannel.h

@@ -65,7 +65,7 @@ namespace grpc_core {
 
 class SubchannelCall;
 
-class ConnectedSubchannel : public RefCounted<ConnectedSubchannel> {
+class ConnectedSubchannel final : public RefCounted<ConnectedSubchannel> {
  public:
   ConnectedSubchannel(
       grpc_channel_stack* channel_stack, const ChannelArgs& args,
@@ -96,7 +96,7 @@ class ConnectedSubchannel : public RefCounted<ConnectedSubchannel> {
 };
 
 // Implements the interface of RefCounted<>.
-class SubchannelCall {
+class SubchannelCall final {
  public:
   struct Args {
     RefCountedPtr<ConnectedSubchannel> connected_subchannel;
@@ -166,7 +166,7 @@ class SubchannelCall {
 // different from the SubchannelInterface that is exposed to LB policy
 // implementations.  The client channel provides an adaptor class
 // (SubchannelWrapper) that "converts" between the two.
-class Subchannel : public DualRefCounted<Subchannel> {
+class Subchannel final : public DualRefCounted<Subchannel> {
  public:
   // TODO(roth): Once we remove pollset_set, consider whether this can
   // just use the normal AsyncConnectivityStateWatcherInterface API.
@@ -250,9 +250,6 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // Resets the connection backoff of the subchannel.
   void ResetBackoff() ABSL_LOCKS_EXCLUDED(mu_);
 
-  // Tears down any existing connection, and arranges for destruction
-  void Orphan() override ABSL_LOCKS_EXCLUDED(mu_);
-
   // Access to data producer map.
   // We do not hold refs to the data producer; the implementation is
   // expected to register itself upon construction and remove itself
@@ -277,9 +274,12 @@ class Subchannel : public DualRefCounted<Subchannel> {
   }
 
  private:
+  // Tears down any existing connection, and arranges for destruction
+  void Orphaned() override ABSL_LOCKS_EXCLUDED(mu_);
+
   // A linked list of ConnectivityStateWatcherInterfaces that are monitoring
   // the subchannel's state.
-  class ConnectivityStateWatcherList {
+  class ConnectivityStateWatcherList final {
    public:
     explicit ConnectivityStateWatcherList(Subchannel* subchannel)
         : subchannel_(subchannel) {}