grpc 1.62.0 → 1.64.0

data/src/core/{ext/filters/server_config_selector → server}/server_config_selector_filter.cc

@@ -12,25 +12,25 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/ext/filters/server_config_selector/server_config_selector_filter.h"
+#include "src/core/server/server_config_selector_filter.h"
 
 #include <functional>
 #include <memory>
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/types/optional.h"
 
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/server_config_selector/server_config_selector.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/channel/promise_based_filter.h"
+#include "src/core/lib/event_engine/event_engine_context.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -40,6 +40,7 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/server/server_config_selector.h"
 #include "src/core/service_config/service_config.h"
 #include "src/core/service_config/service_config_call_data.h"
 
@@ -48,19 +49,22 @@ namespace grpc_core {
 namespace {
 
 class ServerConfigSelectorFilter final
-    : public ImplementChannelFilter<ServerConfigSelectorFilter> {
+    : public ImplementChannelFilter<ServerConfigSelectorFilter>,
+      public InternallyRefCounted<ServerConfigSelectorFilter> {
  public:
-  ~ServerConfigSelectorFilter() override;
+  explicit ServerConfigSelectorFilter(
+      RefCountedPtr<ServerConfigSelectorProvider>
+          server_config_selector_provider);
 
   ServerConfigSelectorFilter(const ServerConfigSelectorFilter&) = delete;
   ServerConfigSelectorFilter& operator=(const ServerConfigSelectorFilter&) =
       delete;
-  ServerConfigSelectorFilter(ServerConfigSelectorFilter&&) = default;
-  ServerConfigSelectorFilter& operator=(ServerConfigSelectorFilter&&) = default;
 
-  static absl::StatusOr<ServerConfigSelectorFilter> Create(
+  static absl::StatusOr<OrphanablePtr<ServerConfigSelectorFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args);
 
+  void Orphan() override;
+
   class Call {
    public:
     absl::Status OnClientInitialMetadata(ClientMetadata& md,
@@ -73,70 +77,66 @@ class ServerConfigSelectorFilter final
   };
 
   absl::StatusOr<RefCountedPtr<ServerConfigSelector>> config_selector() {
-    MutexLock lock(&state_->mu);
-    return state_->config_selector.value();
+    MutexLock lock(&mu_);
+    return config_selector_.value();
   }
 
  private:
-  struct State {
-    Mutex mu;
-    absl::optional<absl::StatusOr<RefCountedPtr<ServerConfigSelector>>>
-        config_selector ABSL_GUARDED_BY(mu);
-  };
   class ServerConfigSelectorWatcher
       : public ServerConfigSelectorProvider::ServerConfigSelectorWatcher {
    public:
-    explicit ServerConfigSelectorWatcher(std::shared_ptr<State> state)
-        : state_(state) {}
+    explicit ServerConfigSelectorWatcher(
+        RefCountedPtr<ServerConfigSelectorFilter> filter)
+        : filter_(filter) {}
     void OnServerConfigSelectorUpdate(
         absl::StatusOr<RefCountedPtr<ServerConfigSelector>> update) override {
-      MutexLock lock(&state_->mu);
-      state_->config_selector = std::move(update);
+      MutexLock lock(&filter_->mu_);
+      filter_->config_selector_ = std::move(update);
     }
 
    private:
-    std::shared_ptr<State> state_;
+    RefCountedPtr<ServerConfigSelectorFilter> filter_;
   };
 
-  explicit ServerConfigSelectorFilter(
-      RefCountedPtr<ServerConfigSelectorProvider>
-          server_config_selector_provider);
-
   RefCountedPtr<ServerConfigSelectorProvider> server_config_selector_provider_;
-  std::shared_ptr<State> state_;
+  Mutex mu_;
+  absl::optional<absl::StatusOr<RefCountedPtr<ServerConfigSelector>>>
+      config_selector_ ABSL_GUARDED_BY(mu_);
 };
 
-absl::StatusOr<ServerConfigSelectorFilter> ServerConfigSelectorFilter::Create(
-    const ChannelArgs& args, ChannelFilter::Args) {
+absl::StatusOr<OrphanablePtr<ServerConfigSelectorFilter>>
+ServerConfigSelectorFilter::Create(const ChannelArgs& args,
+                                   ChannelFilter::Args) {
   ServerConfigSelectorProvider* server_config_selector_provider =
       args.GetObject<ServerConfigSelectorProvider>();
   if (server_config_selector_provider == nullptr) {
     return absl::UnknownError("No ServerConfigSelectorProvider object found");
   }
-  return ServerConfigSelectorFilter(server_config_selector_provider->Ref());
+  return MakeOrphanable<ServerConfigSelectorFilter>(
+      server_config_selector_provider->Ref());
 }
 
 ServerConfigSelectorFilter::ServerConfigSelectorFilter(
     RefCountedPtr<ServerConfigSelectorProvider> server_config_selector_provider)
     : server_config_selector_provider_(
-          std::move(server_config_selector_provider)),
-      state_(std::make_shared<State>()) {
-  GPR_ASSERT(server_config_selector_provider_ != nullptr);
+          std::move(server_config_selector_provider)) {
+  CHECK(server_config_selector_provider_ != nullptr);
   auto server_config_selector_watcher =
-      std::make_unique<ServerConfigSelectorWatcher>(state_);
+      std::make_unique<ServerConfigSelectorWatcher>(Ref());
   auto config_selector = server_config_selector_provider_->Watch(
       std::move(server_config_selector_watcher));
-  MutexLock lock(&state_->mu);
+  MutexLock lock(&mu_);
   // It's possible for the watcher to have already updated config_selector_
-  if (!state_->config_selector.has_value()) {
-    state_->config_selector = std::move(config_selector);
+  if (!config_selector_.has_value()) {
+    config_selector_ = std::move(config_selector);
   }
 }
 
-ServerConfigSelectorFilter::~ServerConfigSelectorFilter() {
+void ServerConfigSelectorFilter::Orphan() {
   if (server_config_selector_provider_ != nullptr) {
     server_config_selector_provider_->CancelWatch();
   }
+  Unref();
 }
 
 absl::Status ServerConfigSelectorFilter::Call::OnClientInitialMetadata(

data/src/core/{ext/filters/server_config_selector → server}/server_config_selector_filter.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_EXT_FILTERS_SERVER_CONFIG_SELECTOR_SERVER_CONFIG_SELECTOR_FILTER_H
-#define GRPC_SRC_CORE_EXT_FILTERS_SERVER_CONFIG_SELECTOR_SERVER_CONFIG_SELECTOR_FILTER_H
+#ifndef GRPC_SRC_CORE_SERVER_SERVER_CONFIG_SELECTOR_FILTER_H
+#define GRPC_SRC_CORE_SERVER_SERVER_CONFIG_SELECTOR_FILTER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -30,4 +30,4 @@ extern const grpc_channel_filter kServerConfigSelectorFilter;
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_FILTERS_SERVER_CONFIG_SELECTOR_SERVER_CONFIG_SELECTOR_FILTER_H
+#endif  // GRPC_SRC_CORE_SERVER_SERVER_CONFIG_SELECTOR_FILTER_H

data/src/core/server/server_interface.h

@@ -0,0 +1,43 @@
+//
+// Copyright 2024 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_SRC_CORE_SERVER_SERVER_INTERFACE_H
+#define GRPC_SRC_CORE_SERVER_SERVER_INTERFACE_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/channelz/channelz.h"
+#include "src/core/lib/channel/channel_args.h"
+
+namespace grpc_core {
+
+class ServerCallTracerFactory;
+
+// This class is a hack to avoid a circular dependency that would be
+// caused by the code in call.cc depending directly on the server code.
+// TODO(roth): After the call v3 migration, find a cleaner way to do this.
+class ServerInterface {
+ public:
+  virtual ~ServerInterface() = default;
+
+  virtual const ChannelArgs& channel_args() const = 0;
+  virtual channelz::ServerNode* channelz_node() const = 0;
+  virtual ServerCallTracerFactory* server_call_tracer_factory() const = 0;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_SERVER_SERVER_INTERFACE_H

data/src/core/{ext/xds → server}/xds_channel_stack_modifier.cc

@@ -16,14 +16,14 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
-#include "src/core/ext/xds/xds_channel_stack_modifier.h"
+#include "src/core/server/xds_channel_stack_modifier.h"
 
 #include <algorithm>
 #include <initializer_list>
 #include <string>
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/config/core_configuration.h"

data/src/core/{ext/xds → server}/xds_channel_stack_modifier.h

@@ -16,10 +16,8 @@
 //
 //
 
-#ifndef GRPC_SRC_CORE_EXT_XDS_XDS_CHANNEL_STACK_MODIFIER_H
-#define GRPC_SRC_CORE_EXT_XDS_XDS_CHANNEL_STACK_MODIFIER_H
-
-#include <grpc/support/port_platform.h>
+#ifndef GRPC_SRC_CORE_SERVER_XDS_CHANNEL_STACK_MODIFIER_H
+#define GRPC_SRC_CORE_SERVER_XDS_CHANNEL_STACK_MODIFIER_H
 
 #include <utility>
 #include <vector>
@@ -27,6 +25,7 @@
 #include "absl/strings/string_view.h"
 
 #include <grpc/grpc.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
@@ -39,7 +38,8 @@ namespace grpc_core {
 // XdsChannelStackModifier allows for inserting xDS HTTP filters into the
 // channel stack. It is registered to mutate the `ChannelStackBuilder` object
 // via ChannelInit::Builder::RegisterPostProcessor.
-class XdsChannelStackModifier : public RefCounted<XdsChannelStackModifier> {
+class XdsChannelStackModifier final
+    : public RefCounted<XdsChannelStackModifier> {
  public:
   explicit XdsChannelStackModifier(
       std::vector<const grpc_channel_filter*> filters)
@@ -60,4 +60,4 @@ class XdsChannelStackModifier : public RefCounted<XdsChannelStackModifier> {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_EXT_XDS_XDS_CHANNEL_STACK_MODIFIER_H
+#endif  // GRPC_SRC_CORE_SERVER_XDS_CHANNEL_STACK_MODIFIER_H

data/src/core/{ext/xds → server}/xds_server_config_fetcher.cc

@@ -16,8 +16,6 @@
 //
 //
 
-#include <grpc/support/port_platform.h>
-
 #include <string.h>
 
 #include <algorithm>
@@ -29,6 +27,7 @@
 #include <vector>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/match.h"
@@ -40,25 +39,14 @@
 #include "absl/types/optional.h"
 #include "absl/types/variant.h"
 
+#include <grpc/credentials.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_security.h>
 #include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/server_config_selector/server_config_selector.h"
-#include "src/core/ext/filters/server_config_selector/server_config_selector_filter.h"
-#include "src/core/ext/xds/certificate_provider_store.h"
-#include "src/core/ext/xds/xds_bootstrap_grpc.h"
-#include "src/core/ext/xds/xds_certificate_provider.h"
-#include "src/core/ext/xds/xds_channel_stack_modifier.h"
-#include "src/core/ext/xds/xds_client.h"
-#include "src/core/ext/xds/xds_client_grpc.h"
-#include "src/core/ext/xds/xds_common_types.h"
-#include "src/core/ext/xds/xds_http_filters.h"
-#include "src/core/ext/xds/xds_listener.h"
-#include "src/core/ext/xds/xds_route_config.h"
-#include "src/core/ext/xds/xds_routing.h"
 #include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -83,11 +71,24 @@
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.h"
 #include "src/core/lib/security/credentials/xds/xds_credentials.h"
 #include "src/core/lib/surface/api_trace.h"
-#include "src/core/lib/surface/server.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/uri/uri_parser.h"
+#include "src/core/server/server.h"
+#include "src/core/server/server_config_selector.h"
+#include "src/core/server/server_config_selector_filter.h"
+#include "src/core/server/xds_channel_stack_modifier.h"
 #include "src/core/service_config/service_config.h"
 #include "src/core/service_config/service_config_impl.h"
+#include "src/core/xds/grpc/certificate_provider_store.h"
+#include "src/core/xds/grpc/xds_bootstrap_grpc.h"
+#include "src/core/xds/grpc/xds_certificate_provider.h"
+#include "src/core/xds/grpc/xds_client_grpc.h"
+#include "src/core/xds/grpc/xds_common_types.h"
+#include "src/core/xds/grpc/xds_http_filters.h"
+#include "src/core/xds/grpc/xds_listener.h"
+#include "src/core/xds/grpc/xds_route_config.h"
+#include "src/core/xds/grpc/xds_routing.h"
+#include "src/core/xds/xds_client/xds_client.h"
 
 namespace grpc_core {
 namespace {
@@ -99,7 +100,7 @@ TraceFlag grpc_xds_server_config_fetcher_trace(false,
 
 // A server config fetcher that fetches the information for configuring server
 // listeners from the xDS control plane.
-class XdsServerConfigFetcher : public grpc_server_config_fetcher {
+class XdsServerConfigFetcher final : public grpc_server_config_fetcher {
  public:
   XdsServerConfigFetcher(RefCountedPtr<GrpcXdsClient> xds_client,
                          grpc_server_xds_status_notifier notifier);
@@ -140,7 +141,7 @@ class XdsServerConfigFetcher : public grpc_server_config_fetcher {
 // continues to be used. If there isn't any previous good update or if the
 // update received was a fatal error (resource does not exist), the server
 // listener is made to stop listening.
-class XdsServerConfigFetcher::ListenerWatcher
+class XdsServerConfigFetcher::ListenerWatcher final
     : public XdsListenerResourceType::WatcherInterface {
  public:
   ListenerWatcher(RefCountedPtr<GrpcXdsClient> xds_client,
@@ -200,7 +201,7 @@ class XdsServerConfigFetcher::ListenerWatcher
 // appropriate filter chain from the xDS Listener resource and injects channel
 // args that configure the right mTLS certs and cause the right set of HTTP
 // filters to be injected.
-class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager
+class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager final
     : public grpc_server_config_fetcher::ConnectionManager {
  public:
   FilterChainMatchManager(RefCountedPtr<GrpcXdsClient> xds_client,
@@ -215,8 +216,6 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager
   absl::StatusOr<ChannelArgs> UpdateChannelArgsForConnection(
       const ChannelArgs& args, grpc_endpoint* tcp) override;
 
-  void Orphan() override;
-
   // Invoked by ListenerWatcher to start fetching referenced RDS resources.
   void StartRdsWatch(RefCountedPtr<ListenerWatcher> listener_watcher)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ListenerWatcher::mu_);
@@ -246,6 +245,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager
   absl::StatusOr<RefCountedPtr<XdsCertificateProvider>>
   CreateOrGetXdsCertificateProviderFromFilterChainData(
       const XdsListenerResource::FilterChainData* filter_chain);
+  void Orphaned() override;
 
   // Helper functions invoked by RouteConfigWatcher when there are updates to
   // RDS resources.
@@ -281,7 +281,8 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager
 // with the latest updates and new connections do not need to wait for the RDS
 // resources to be fetched.
 class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
-    RouteConfigWatcher : public XdsRouteConfigResourceType::WatcherInterface {
+    RouteConfigWatcher final
+    : public XdsRouteConfigResourceType::WatcherInterface {
  public:
   RouteConfigWatcher(
       std::string resource_name,
@@ -317,7 +318,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
 // DynamicXdsServerConfigSelectorProvider to parse the RDS update and get
 // per-call configuration based on incoming metadata.
 class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
-    XdsServerConfigSelector : public ServerConfigSelector {
+    XdsServerConfigSelector final : public ServerConfigSelector {
  public:
   static absl::StatusOr<RefCountedPtr<XdsServerConfigSelector>> Create(
       const XdsHttpFilterRegistry& http_filter_registry,
@@ -341,7 +342,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
       RefCountedPtr<ServiceConfig> method_config;
     };
 
-    class RouteListIterator : public XdsRouting::RouteListIterator {
+    class RouteListIterator final : public XdsRouting::RouteListIterator {
      public:
       explicit RouteListIterator(const std::vector<Route>* routes)
           : routes_(routes) {}
@@ -361,7 +362,8 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     std::vector<Route> routes;
   };
 
-  class VirtualHostListIterator : public XdsRouting::VirtualHostListIterator {
+  class VirtualHostListIterator final
+      : public XdsRouting::VirtualHostListIterator {
    public:
     explicit VirtualHostListIterator(
         const std::vector<VirtualHost>* virtual_hosts)
@@ -384,7 +386,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
 // An XdsServerConfigSelectorProvider implementation for when the
 // RouteConfiguration is available inline.
 class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
-    StaticXdsServerConfigSelectorProvider
+    StaticXdsServerConfigSelectorProvider final
     : public ServerConfigSelectorProvider {
  public:
   StaticXdsServerConfigSelectorProvider(
@@ -404,7 +406,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
   absl::StatusOr<RefCountedPtr<ServerConfigSelector>> Watch(
       std::unique_ptr<ServerConfigSelectorProvider::ServerConfigSelectorWatcher>
           watcher) override {
-    GPR_ASSERT(watcher_ == nullptr);
+    CHECK(watcher_ == nullptr);
     watcher_ = std::move(watcher);
     if (!static_resource_.ok()) {
       return static_resource_.status();
@@ -415,11 +417,11 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
         static_resource_.value(), http_filters_);
   }
 
-  void Orphan() override {}
-
   void CancelWatch() override { watcher_.reset(); }
 
  private:
+  void Orphaned() override {}
+
   RefCountedPtr<GrpcXdsClient> xds_client_;
   absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>>
       static_resource_;
@@ -435,7 +437,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
 // An XdsServerConfigSelectorProvider implementation for when the
 // RouteConfiguration is to be fetched separately via RDS.
 class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
-    DynamicXdsServerConfigSelectorProvider
+    DynamicXdsServerConfigSelectorProvider final
     : public ServerConfigSelectorProvider {
  public:
   DynamicXdsServerConfigSelectorProvider(
@@ -449,8 +451,6 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
     xds_client_.reset(DEBUG_LOCATION, "DynamicXdsServerConfigSelectorProvider");
   }
 
-  void Orphan() override;
-
   absl::StatusOr<RefCountedPtr<ServerConfigSelector>> Watch(
       std::unique_ptr<ServerConfigSelectorProvider::ServerConfigSelectorWatcher>
           watcher) override;
@@ -459,6 +459,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
  private:
   class RouteConfigWatcher;
 
+  void Orphaned() override;
   void OnRouteConfigChanged(
       std::shared_ptr<const XdsRouteConfigResource> rds_update);
   void OnError(absl::Status status);
@@ -482,7 +483,7 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
 // A watcher implementation for updating the RDS resource used by
 // DynamicXdsServerConfigSelectorProvider
 class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
-    DynamicXdsServerConfigSelectorProvider::RouteConfigWatcher
+    DynamicXdsServerConfigSelectorProvider::RouteConfigWatcher final
     : public XdsRouteConfigResourceType::WatcherInterface {
  public:
   explicit RouteConfigWatcher(
@@ -518,7 +519,7 @@ XdsServerConfigFetcher::XdsServerConfigFetcher(
     RefCountedPtr<GrpcXdsClient> xds_client,
     grpc_server_xds_status_notifier notifier)
     : xds_client_(std::move(xds_client)), serving_status_notifier_(notifier) {
-  GPR_ASSERT(xds_client_ != nullptr);
+  CHECK(xds_client_ != nullptr);
 }
 
 std::string ListenerResourceName(absl::string_view resource_name_template,
@@ -783,7 +784,7 @@ void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
 }
 
 void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
-    Orphan() {
+    Orphaned() {
   MutexLock lock(&mu_);
   // Cancel the RDS watches to clear up the weak refs
   for (const auto& entry : rds_map_) {
@@ -1102,7 +1103,7 @@ absl::StatusOr<ChannelArgs> XdsServerConfigFetcher::ListenerWatcher::
     const XdsHttpFilterImpl* filter_impl =
         http_filter_registry.GetFilterForType(
             http_filter.config.config_proto_type_name);
-    GPR_ASSERT(filter_impl != nullptr);
+    CHECK_NE(filter_impl, nullptr);
     // Some filters like the router filter are no-op filters and do not have
     // an implementation.
     if (filter_impl->channel_filter() != nullptr) {
@@ -1151,7 +1152,7 @@ absl::StatusOr<ChannelArgs> XdsServerConfigFetcher::ListenerWatcher::
       return result.status();
     }
     xds_certificate_provider = std::move(*result);
-    GPR_ASSERT(xds_certificate_provider != nullptr);
+    CHECK(xds_certificate_provider != nullptr);
     args = args.SetObject(xds_certificate_provider);
   }
   return args;
@@ -1269,7 +1270,7 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
       resource_name_(std::move(resource_name)),
       http_filters_(std::move(http_filters)),
       resource_(std::move(initial_resource)) {
-  GPR_ASSERT(!resource_name_.empty());
+  CHECK(!resource_name_.empty());
   // RouteConfigWatcher is being created here instead of in Watch() to avoid
   // deadlocks from invoking XdsRouteConfigResourceType::StartWatch whilst in a
   // critical region.
@@ -1281,7 +1282,7 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
 }
 
 void XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
-    DynamicXdsServerConfigSelectorProvider::Orphan() {
+    DynamicXdsServerConfigSelectorProvider::Orphaned() {
   XdsRouteConfigResourceType::CancelWatch(xds_client_.get(), resource_name_,
                                           route_config_watcher_,
                                           false /* delay_unsubscription */);
@@ -1296,7 +1297,7 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
   absl::StatusOr<std::shared_ptr<const XdsRouteConfigResource>> resource;
   {
     MutexLock lock(&mu_);
-    GPR_ASSERT(watcher_ == nullptr);
+    CHECK(watcher_ == nullptr);
     watcher_ = std::move(watcher);
     resource = resource_;
   }
@@ -1372,7 +1373,8 @@ grpc_server_config_fetcher* grpc_server_config_fetcher_xds_create(
       "update=%p, user_data=%p}, args=%p)",
       3, (notifier.on_serving_status_update, notifier.user_data, args));
   auto xds_client = grpc_core::GrpcXdsClient::GetOrCreate(
-      channel_args, "XdsServerConfigFetcher");
+      grpc_core::GrpcXdsClient::kServerKey, channel_args,
+      "XdsServerConfigFetcher");
   if (!xds_client.ok()) {
     gpr_log(GPR_ERROR, "Failed to create xds client: %s",
             xds_client.status().ToString().c_str());

data/src/core/service_config/service_config.h

@@ -17,13 +17,12 @@
 #ifndef GRPC_SRC_CORE_SERVICE_CONFIG_SERVICE_CONFIG_H
 #define GRPC_SRC_CORE_SERVICE_CONFIG_SERVICE_CONFIG_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 
 #include "absl/strings/string_view.h"
 
 #include <grpc/slice.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/ref_counted.h"

data/src/core/service_config/service_config_call_data.h

@@ -17,13 +17,13 @@
 #ifndef GRPC_SRC_CORE_SERVICE_CONFIG_SERVICE_CONFIG_CALL_DATA_H
 #define GRPC_SRC_CORE_SERVICE_CONFIG_SERVICE_CONFIG_CALL_DATA_H
 
-#include <grpc/support/port_platform.h>
-
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/gprpp/chunked_vector.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"

data/src/core/{client_channel → service_config}/service_config_channel_arg_filter.cc

@@ -17,8 +17,6 @@
 // This filter reads GRPC_ARG_SERVICE_CONFIG and populates ServiceConfigCallData
 // in the call context per call for direct channels.
 
-#include <grpc/support/port_platform.h>
-
 #include <functional>
 #include <memory>
 #include <string>
@@ -30,6 +28,7 @@
 
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
 
 #include "src/core/ext/filters/message_size/message_size_filter.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -42,26 +41,26 @@
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
 #include "src/core/service_config/service_config.h"
 #include "src/core/service_config/service_config_call_data.h"
 #include "src/core/service_config/service_config_impl.h"
 #include "src/core/service_config/service_config_parser.h"
-#include "src/core/lib/surface/channel_stack_type.h"
-#include "src/core/lib/transport/metadata_batch.h"
-#include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 
 namespace {
 
-class ServiceConfigChannelArgFilter
+class ServiceConfigChannelArgFilter final
     : public ImplementChannelFilter<ServiceConfigChannelArgFilter> {
  public:
   static const grpc_channel_filter kFilter;
 
-  static absl::StatusOr<ServiceConfigChannelArgFilter> Create(
+  static absl::StatusOr<std::unique_ptr<ServiceConfigChannelArgFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args) {
-    return ServiceConfigChannelArgFilter(args);
+    return std::make_unique<ServiceConfigChannelArgFilter>(args);
   }
 
   explicit ServiceConfigChannelArgFilter(const ChannelArgs& args) {

data/src/core/service_config/service_config_impl.cc

@@ -14,8 +14,6 @@
 // limitations under the License.
 //
 
-#include <grpc/support/port_platform.h>
-
 #include "src/core/service_config/service_config_impl.h"
 
 #include <string.h>
@@ -28,6 +26,8 @@
 #include "absl/strings/str_cat.h"
 #include "absl/types/optional.h"
 
+#include <grpc/support/port_platform.h>
+
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/validation_errors.h"