grpc 1.54.2 → 1.61.0

data/src/core/ext/filters/client_channel/resolver/xds/xds_resolver.cc

@@ -16,12 +16,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdlib.h>
+#include <stdint.h>
 #include <string.h>
 
 #include <algorithm>
-#include <cstdint>
-#include <initializer_list>
+#include <functional>
 #include <map>
 #include <memory>
 #include <string>
@@ -44,20 +43,17 @@
 #include "absl/types/variant.h"
 #include "re2/re2.h"
 
-#include <grpc/grpc.h>
-
-#include "src/core/lib/gprpp/unique_type_name.h"
-#include "src/core/lib/slice/slice.h"
-
-#define XXH_INLINE_ALL
-#include "xxhash.h"
-
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
 
+#include "src/core/ext/filters/client_channel/client_channel_internal.h"
 #include "src/core/ext/filters/client_channel/config_selector.h"
 #include "src/core/ext/filters/client_channel/lb_policy/ring_hash/ring_hash.h"
+#include "src/core/ext/filters/client_channel/resolver/xds/xds_dependency_manager.h"
+#include "src/core/ext/filters/client_channel/resolver/xds/xds_resolver_attributes.h"
+#include "src/core/ext/filters/client_channel/resolver/xds/xds_resolver_trace.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_bootstrap_grpc.h"
 #include "src/core/ext/xds/xds_client_grpc.h"
@@ -67,68 +63,54 @@
 #include "src/core/ext/xds/xds_routing.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"
+#include "src/core/lib/channel/context.h"
+#include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
 #include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/gprpp/work_serializer.h"
+#include "src/core/lib/gprpp/xxhash_inline.h"
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/resolver/endpoint_addresses.h"
 #include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/resolver/resolver_factory.h"
-#include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/service_config/service_config.h"
 #include "src/core/lib/service_config/service_config_impl.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 namespace grpc_core {
 
-TraceFlag grpc_xds_resolver_trace(false, "xds_resolver");
-
-UniqueTypeName XdsClusterAttributeTypeName() {
-  static UniqueTypeName::Factory kFactory("xds_cluster_name");
-  return kFactory.Create();
-}
-
 namespace {
 
-std::string GetDefaultAuthorityInternal(const URI& uri) {
-  // Obtain the authority to use for the data plane connections, which is
-  // also used to select the right VirtualHost from the RouteConfiguration.
-  // We need to take the part of the URI path following the last
-  // "/" character or the entire path if the path contains no "/" character.
-  size_t pos = uri.path().find_last_of('/');
-  if (pos == uri.path().npos) return uri.path();
-  return uri.path().substr(pos + 1);
-}
-
-std::string GetDataPlaneAuthority(const ChannelArgs& args, const URI& uri) {
-  absl::optional<std::string> authority =
-      args.GetOwnedString(GRPC_ARG_DEFAULT_AUTHORITY);
-  if (authority.has_value()) return std::move(*authority);
-  return GetDefaultAuthorityInternal(uri);
-}
-
 //
 // XdsResolver
 //
 
 class XdsResolver : public Resolver {
  public:
-  explicit XdsResolver(ResolverArgs args)
+  XdsResolver(ResolverArgs args, std::string data_plane_authority)
       : work_serializer_(std::move(args.work_serializer)),
         result_handler_(std::move(args.result_handler)),
         args_(std::move(args.args)),
         interested_parties_(args.pollset_set),
         uri_(std::move(args.uri)),
-        data_plane_authority_(GetDataPlaneAuthority(args_, uri_)),
+        data_plane_authority_(std::move(data_plane_authority)),
         channel_id_(absl::Uniform<uint64_t>(absl::BitGen())) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
       gpr_log(
@@ -153,77 +135,22 @@ class XdsResolver : public Resolver {
   }
 
  private:
-  class ListenerWatcher : public XdsListenerResourceType::WatcherInterface {
+  class XdsWatcher : public XdsDependencyManager::Watcher {
    public:
-    explicit ListenerWatcher(RefCountedPtr<XdsResolver> resolver)
+    explicit XdsWatcher(RefCountedPtr<XdsResolver> resolver)
         : resolver_(std::move(resolver)) {}
-    void OnResourceChanged(XdsListenerResource listener) override {
-      RefCountedPtr<ListenerWatcher> self = Ref();
-      resolver_->work_serializer_->Run(
-          [self = std::move(self), listener = std::move(listener)]() mutable {
-            self->resolver_->OnListenerUpdate(std::move(listener));
-          },
-          DEBUG_LOCATION);
-    }
-    void OnError(absl::Status status) override {
-      RefCountedPtr<ListenerWatcher> self = Ref();
-      resolver_->work_serializer_->Run(
-          [self = std::move(self), status = std::move(status)]() mutable {
-            self->resolver_->OnError(self->resolver_->lds_resource_name_,
-                                     std::move(status));
-          },
-          DEBUG_LOCATION);
-    }
-    void OnResourceDoesNotExist() override {
-      RefCountedPtr<ListenerWatcher> self = Ref();
-      resolver_->work_serializer_->Run(
-          [self = std::move(self)]() {
-            self->resolver_->OnResourceDoesNotExist(
-                absl::StrCat(self->resolver_->lds_resource_name_,
-                             ": xDS listener resource does not exist"));
-          },
-          DEBUG_LOCATION);
-    }
-
-   private:
-    RefCountedPtr<XdsResolver> resolver_;
-  };
 
-  class RouteConfigWatcher
-      : public XdsRouteConfigResourceType::WatcherInterface {
-   public:
-    explicit RouteConfigWatcher(RefCountedPtr<XdsResolver> resolver)
-        : resolver_(std::move(resolver)) {}
-    void OnResourceChanged(XdsRouteConfigResource route_config) override {
-      RefCountedPtr<RouteConfigWatcher> self = Ref();
-      resolver_->work_serializer_->Run(
-          [self = std::move(self),
-           route_config = std::move(route_config)]() mutable {
-            if (self != self->resolver_->route_config_watcher_) return;
-            self->resolver_->OnRouteConfigUpdate(std::move(route_config));
-          },
-          DEBUG_LOCATION);
+    void OnUpdate(
+        RefCountedPtr<const XdsDependencyManager::XdsConfig> config) override {
+      resolver_->OnUpdate(std::move(config));
     }
-    void OnError(absl::Status status) override {
-      RefCountedPtr<RouteConfigWatcher> self = Ref();
-      resolver_->work_serializer_->Run(
-          [self = std::move(self), status = std::move(status)]() mutable {
-            if (self != self->resolver_->route_config_watcher_) return;
-            self->resolver_->OnError(self->resolver_->route_config_name_,
-                                     std::move(status));
-          },
-          DEBUG_LOCATION);
+
+    void OnError(absl::string_view context, absl::Status status) override {
+      resolver_->OnError(context, std::move(status));
     }
-    void OnResourceDoesNotExist() override {
-      RefCountedPtr<RouteConfigWatcher> self = Ref();
-      resolver_->work_serializer_->Run(
-          [self = std::move(self)]() {
-            if (self != self->resolver_->route_config_watcher_) return;
-            self->resolver_->OnResourceDoesNotExist(absl::StrCat(
-                self->resolver_->route_config_name_,
-                ": xDS route configuration resource does not exist"));
-          },
-          DEBUG_LOCATION);
+
+    void OnResourceDoesNotExist(std::string context) override {
+      resolver_->OnResourceDoesNotExist(std::move(context));
     }
 
    private:
@@ -236,66 +163,113 @@ class XdsResolver : public Resolver {
   // the cluster by the ConfigSelector.  The ref for each call is held
   // until the call is committed.  When the strong refs go away, we hop
   // back into the WorkSerializer to remove the entry from the map.
-  class ClusterState : public DualRefCounted<ClusterState> {
+  class ClusterRef : public DualRefCounted<ClusterRef> {
    public:
-    using ClusterStateMap =
-        std::map<std::string, WeakRefCountedPtr<ClusterState>>;
-
-    ClusterState(RefCountedPtr<XdsResolver> resolver,
-                 const std::string& cluster_name)
+    ClusterRef(RefCountedPtr<XdsResolver> resolver,
+               RefCountedPtr<XdsDependencyManager::ClusterSubscription>
+                   cluster_subscription,
+               absl::string_view cluster_key)
         : resolver_(std::move(resolver)),
-          it_(resolver_->cluster_state_map_.emplace(cluster_name, WeakRef())
-                  .first) {}
+          cluster_subscription_(std::move(cluster_subscription)),
+          cluster_key_(cluster_key) {}
 
     void Orphan() override {
-      auto* resolver = resolver_.release();
-      resolver->work_serializer_->Run(
-          [resolver]() {
+      XdsResolver* resolver_ptr = resolver_.get();
+      resolver_ptr->work_serializer_->Run(
+          [resolver = std::move(resolver_)]() {
             resolver->MaybeRemoveUnusedClusters();
-            resolver->Unref();
           },
           DEBUG_LOCATION);
+      cluster_subscription_.reset();
     }
 
-    const std::string& cluster() const { return it_->first; }
+    const std::string& cluster_key() const { return cluster_key_; }
 
    private:
     RefCountedPtr<XdsResolver> resolver_;
-    ClusterStateMap::iterator it_;
+    RefCountedPtr<XdsDependencyManager::ClusterSubscription>
+        cluster_subscription_;
+    std::string cluster_key_;
   };
 
-  // Call dispatch controller, created for each call handled by the
-  // ConfigSelector.  Holds a ref to the ClusterState object until the
-  // call is committed.
-  class XdsCallDispatchController
-      : public ConfigSelector::CallDispatchController {
+  // A routing data including cluster refs and routes table held by the
+  // XdsConfigSelector. A ref to this map will be taken by each call processed
+  // by the XdsConfigSelector, stored in a the call's call attributes, and later
+  // unreffed by the ClusterSelection filter.
+  class RouteConfigData : public RefCounted<RouteConfigData> {
    public:
-    explicit XdsCallDispatchController(
-        RefCountedPtr<ClusterState> cluster_state)
-        : cluster_state_(std::move(cluster_state)) {}
+    struct RouteEntry {
+      struct ClusterWeightState {
+        uint32_t range_end;
+        absl::string_view cluster;
+        RefCountedPtr<ServiceConfig> method_config;
+
+        bool operator==(const ClusterWeightState& other) const {
+          return range_end == other.range_end && cluster == other.cluster &&
+                 MethodConfigsEqual(method_config.get(),
+                                    other.method_config.get());
+        }
+      };
+
+      XdsRouteConfigResource::Route route;
+      RefCountedPtr<ServiceConfig> method_config;
+      std::vector<ClusterWeightState> weighted_cluster_state;
+
+      explicit RouteEntry(const XdsRouteConfigResource::Route& r) : route(r) {}
 
-    bool ShouldRetry() override {
-      // TODO(donnadionne): Implement the retry circuit breaker here.
-      return true;
+      bool operator==(const RouteEntry& other) const {
+        return route == other.route &&
+               weighted_cluster_state == other.weighted_cluster_state &&
+               MethodConfigsEqual(method_config.get(),
+                                  other.method_config.get());
+      }
+    };
+
+    static absl::StatusOr<RefCountedPtr<RouteConfigData>> Create(
+        XdsResolver* resolver, const Duration& default_max_stream_duration);
+
+    bool operator==(const RouteConfigData& other) const {
+      return clusters_ == other.clusters_ && routes_ == other.routes_;
     }
 
-    void Commit() override {
-      // TODO(donnadionne): If ShouldRetry() was called previously,
-      // decrement the retry circuit breaker counter.
-      cluster_state_.reset();
+    RefCountedPtr<ClusterRef> FindClusterRef(absl::string_view name) const {
+      auto it = clusters_.find(name);
+      if (it == clusters_.end()) {
+        return nullptr;
+      }
+      return it->second;
     }
 
+    RouteEntry* GetRouteForRequest(absl::string_view path,
+                                   grpc_metadata_batch* initial_metadata);
+
    private:
-    // Note: The XdsCallDispatchController object is never actually destroyed,
-    // so do not add any data members that require destruction unless you have
-    // some other way to clean them up.
-    RefCountedPtr<ClusterState> cluster_state_;
+    class RouteListIterator;
+
+    static absl::StatusOr<RefCountedPtr<ServiceConfig>> CreateMethodConfig(
+        XdsResolver* resolver, const XdsRouteConfigResource::Route& route,
+        const XdsRouteConfigResource::Route::RouteAction::ClusterWeight*
+            cluster_weight);
+
+    static bool MethodConfigsEqual(const ServiceConfig* sc1,
+                                   const ServiceConfig* sc2) {
+      if (sc1 == nullptr) return sc2 == nullptr;
+      if (sc2 == nullptr) return false;
+      return sc1->json_string() == sc2->json_string();
+    }
+
+    absl::Status AddRouteEntry(XdsResolver* resolver,
+                               const XdsRouteConfigResource::Route& route,
+                               const Duration& default_max_stream_duration);
+
+    std::map<absl::string_view, RefCountedPtr<ClusterRef>> clusters_;
+    std::vector<RouteEntry> routes_;
   };
 
   class XdsConfigSelector : public ConfigSelector {
    public:
     XdsConfigSelector(RefCountedPtr<XdsResolver> resolver,
-                      absl::Status* status);
+                      RefCountedPtr<RouteConfigData> route_config_data);
     ~XdsConfigSelector() override;
 
     const char* name() const override { return "XdsConfigSelector"; }
@@ -303,57 +277,95 @@ class XdsResolver : public Resolver {
     bool Equals(const ConfigSelector* other) const override {
       const auto* other_xds = static_cast<const XdsConfigSelector*>(other);
       // Don't need to compare resolver_, since that will always be the same.
-      return route_table_ == other_xds->route_table_ &&
-             clusters_ == other_xds->clusters_;
+      return *route_config_data_ == *other_xds->route_config_data_ &&
+             filters_ == other_xds->filters_;
     }
 
-    absl::StatusOr<CallConfig> GetCallConfig(GetCallConfigArgs args) override;
+    absl::Status GetCallConfig(GetCallConfigArgs args) override;
 
     std::vector<const grpc_channel_filter*> GetFilters() override {
       return filters_;
     }
 
    private:
-    struct Route {
-      struct ClusterWeightState {
-        uint32_t range_end;
-        absl::string_view cluster;
-        RefCountedPtr<ServiceConfig> method_config;
+    RefCountedPtr<XdsResolver> resolver_;
+    RefCountedPtr<RouteConfigData> route_config_data_;
+    std::vector<const grpc_channel_filter*> filters_;
+  };
 
-        bool operator==(const ClusterWeightState& other) const;
-      };
+  class XdsRouteStateAttributeImpl : public XdsRouteStateAttribute {
+   public:
+    explicit XdsRouteStateAttributeImpl(
+        RefCountedPtr<RouteConfigData> route_config_data,
+        RouteConfigData::RouteEntry* route)
+        : route_config_data_(std::move(route_config_data)), route_(route) {}
 
-      XdsRouteConfigResource::Route route;
-      RefCountedPtr<ServiceConfig> method_config;
-      std::vector<ClusterWeightState> weighted_cluster_state;
+    // This method can be called only once. The first call will release
+    // the reference to the cluster map, and subsequent calls will return
+    // nullptr.
+    RefCountedPtr<ClusterRef> LockAndGetCluster(absl::string_view cluster_name);
 
-      bool operator==(const Route& other) const;
-    };
-    using RouteTable = std::vector<Route>;
+    bool HasClusterForRoute(absl::string_view cluster_name) const override;
 
-    class RouteListIterator;
+   private:
+    RefCountedPtr<RouteConfigData> route_config_data_;
+    RouteConfigData::RouteEntry* route_;
+  };
 
-    void MaybeAddCluster(const std::string& name);
-    absl::StatusOr<RefCountedPtr<ServiceConfig>> CreateMethodConfig(
-        const XdsRouteConfigResource::Route& route,
-        const XdsRouteConfigResource::Route::RouteAction::ClusterWeight*
-            cluster_weight);
+  class ClusterSelectionFilter
+      : public ImplementChannelFilter<ClusterSelectionFilter> {
+   public:
+    const static grpc_channel_filter kFilter;
 
-    RefCountedPtr<XdsResolver> resolver_;
-    RouteTable route_table_;
-    std::map<absl::string_view, RefCountedPtr<ClusterState>> clusters_;
-    std::vector<const grpc_channel_filter*> filters_;
+    static absl::StatusOr<ClusterSelectionFilter> Create(
+        const ChannelArgs& /* unused */, ChannelFilter::Args filter_args) {
+      return ClusterSelectionFilter(filter_args);
+    }
+
+    // Construct a promise for one call.
+    class Call {
+     public:
+      void OnClientInitialMetadata(ClientMetadata& md);
+      static const NoInterceptor OnServerInitialMetadata;
+      static const NoInterceptor OnServerTrailingMetadata;
+      static const NoInterceptor OnClientToServerMessage;
+      static const NoInterceptor OnServerToClientMessage;
+      static const NoInterceptor OnFinalize;
+    };
+
+   private:
+    explicit ClusterSelectionFilter(ChannelFilter::Args filter_args)
+        : filter_args_(filter_args) {}
+
+    ChannelFilter::Args filter_args_;
   };
 
-  void OnListenerUpdate(XdsListenerResource listener);
-  void OnRouteConfigUpdate(XdsRouteConfigResource rds_update);
+  RefCountedPtr<ClusterRef> GetOrCreateClusterRef(
+      absl::string_view cluster_key, absl::string_view cluster_name) {
+    auto it = cluster_ref_map_.find(cluster_key);
+    if (it == cluster_ref_map_.end()) {
+      RefCountedPtr<XdsDependencyManager::ClusterSubscription> subscription;
+      if (!cluster_name.empty()) {
+        // The cluster ref will hold a subscription to ensure that the
+        // XdsDependencyManager stays subscribed to the CDS resource as
+        // long as the cluster ref exists.
+        subscription = dependency_mgr_->GetClusterSubscription(cluster_name);
+      }
+      auto cluster = MakeRefCounted<ClusterRef>(
+          RefAsSubclass<XdsResolver>(), std::move(subscription), cluster_key);
+      cluster_ref_map_.emplace(cluster->cluster_key(), cluster->WeakRef());
+      return cluster;
+    }
+    return it->second->Ref();
+  }
+
+  void OnUpdate(RefCountedPtr<const XdsDependencyManager::XdsConfig> config);
   void OnError(absl::string_view context, absl::Status status);
   void OnResourceDoesNotExist(std::string context);
 
   absl::StatusOr<RefCountedPtr<ServiceConfig>> CreateServiceConfig();
   void GenerateResult();
   void MaybeRemoveUnusedClusters();
-  uint64_t channel_id() const { return channel_id_; }
 
   std::shared_ptr<WorkSerializer> work_serializer_;
   std::unique_ptr<ResultHandler> result_handler_;
@@ -363,187 +375,84 @@ class XdsResolver : public Resolver {
   RefCountedPtr<GrpcXdsClient> xds_client_;
   std::string lds_resource_name_;
   std::string data_plane_authority_;
-  uint64_t channel_id_;
-
-  ListenerWatcher* listener_watcher_ = nullptr;
-  // This will not contain the RouteConfiguration, even if it comes with the
-  // LDS response; instead, the relevant VirtualHost from the
-  // RouteConfiguration will be saved in current_virtual_host_.
-  XdsListenerResource::HttpConnectionManager current_listener_;
-
-  std::string route_config_name_;
-  RouteConfigWatcher* route_config_watcher_ = nullptr;
-  absl::optional<XdsRouteConfigResource::VirtualHost> current_virtual_host_;
-  std::map<std::string /*cluster_specifier_plugin_name*/,
-           std::string /*LB policy config*/>
-      cluster_specifier_plugin_map_;
-
-  ClusterState::ClusterStateMap cluster_state_map_;
+  const uint64_t channel_id_;
+
+  OrphanablePtr<XdsDependencyManager> dependency_mgr_;
+  RefCountedPtr<const XdsDependencyManager::XdsConfig> current_config_;
+  std::map<absl::string_view, WeakRefCountedPtr<ClusterRef>> cluster_ref_map_;
 };
 
+const NoInterceptor
+    XdsResolver::ClusterSelectionFilter::Call::OnServerInitialMetadata;
+const NoInterceptor
+    XdsResolver::ClusterSelectionFilter::Call::OnServerTrailingMetadata;
+const NoInterceptor
+    XdsResolver::ClusterSelectionFilter::Call::OnClientToServerMessage;
+const NoInterceptor
+    XdsResolver::ClusterSelectionFilter::Call::OnServerToClientMessage;
+const NoInterceptor XdsResolver::ClusterSelectionFilter::Call::OnFinalize;
+
 //
-// XdsResolver::XdsConfigSelector::Route
+// XdsResolver::RouteConfigData::RouteListIterator
 //
 
-bool MethodConfigsEqual(const ServiceConfig* sc1, const ServiceConfig* sc2) {
-  if (sc1 == nullptr) return sc2 == nullptr;
-  if (sc2 == nullptr) return false;
-  return sc1->json_string() == sc2->json_string();
-}
-
-bool XdsResolver::XdsConfigSelector::Route::ClusterWeightState::operator==(
-    const ClusterWeightState& other) const {
-  return range_end == other.range_end && cluster == other.cluster &&
-         MethodConfigsEqual(method_config.get(), other.method_config.get());
-}
-
-bool XdsResolver::XdsConfigSelector::Route::operator==(
-    const Route& other) const {
-  return route == other.route &&
-         weighted_cluster_state == other.weighted_cluster_state &&
-         MethodConfigsEqual(method_config.get(), other.method_config.get());
-}
-
 // Implementation of XdsRouting::RouteListIterator for getting the matching
 // route for a request.
-class XdsResolver::XdsConfigSelector::RouteListIterator
+class XdsResolver::RouteConfigData::RouteListIterator
     : public XdsRouting::RouteListIterator {
  public:
-  explicit RouteListIterator(const RouteTable* route_table)
+  explicit RouteListIterator(const RouteConfigData* route_table)
       : route_table_(route_table) {}
 
-  size_t Size() const override { return route_table_->size(); }
+  size_t Size() const override { return route_table_->routes_.size(); }
 
   const XdsRouteConfigResource::Route::Matchers& GetMatchersForRoute(
       size_t index) const override {
-    return (*route_table_)[index].route.matchers;
+    return route_table_->routes_[index].route.matchers;
   }
 
  private:
-  const RouteTable* route_table_;
+  const RouteConfigData* route_table_;
 };
 
 //
-// XdsResolver::XdsConfigSelector
+// XdsResolver::RouteConfigData
 //
 
-XdsResolver::XdsConfigSelector::XdsConfigSelector(
-    RefCountedPtr<XdsResolver> resolver, absl::Status* status)
-    : resolver_(std::move(resolver)) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
-    gpr_log(GPR_INFO, "[xds_resolver %p] creating XdsConfigSelector %p",
-            resolver_.get(), this);
-  }
-  // 1. Construct the route table
-  // 2  Update resolver's cluster state map
-  // 3. Construct cluster list to hold on to entries in the cluster state
-  // map.
+absl::StatusOr<RefCountedPtr<XdsResolver::RouteConfigData>>
+XdsResolver::RouteConfigData::Create(
+    XdsResolver* resolver, const Duration& default_max_stream_duration) {
+  auto data = MakeRefCounted<RouteConfigData>();
   // Reserve the necessary entries up-front to avoid reallocation as we add
   // elements. This is necessary because the string_view in the entry's
   // weighted_cluster_state field points to the memory in the route field, so
   // moving the entry in a reallocation will cause the string_view to point to
   // invalid data.
-  route_table_.reserve(resolver_->current_virtual_host_->routes.size());
-  for (auto& route : resolver_->current_virtual_host_->routes) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
-      gpr_log(GPR_INFO, "[xds_resolver %p] XdsConfigSelector %p: route: %s",
-              resolver_.get(), this, route.ToString().c_str());
-    }
-    route_table_.emplace_back();
-    auto& route_entry = route_table_.back();
-    route_entry.route = route;
-    auto* route_action =
-        absl::get_if<XdsRouteConfigResource::Route::RouteAction>(
-            &route_entry.route.action);
-    if (route_action != nullptr) {
-      // If the route doesn't specify a timeout, set its timeout to the global
-      // one.
-      if (!route_action->max_stream_duration.has_value()) {
-        route_action->max_stream_duration =
-            resolver_->current_listener_.http_max_stream_duration;
-      }
-      Match(
-          route_action->action,
-          // cluster name
-          [&](const XdsRouteConfigResource::Route::RouteAction::ClusterName&
-                  cluster_name) {
-            auto result = CreateMethodConfig(route_entry.route, nullptr);
-            if (!result.ok()) {
-              *status = result.status();
-              return;
-            }
-            route_entry.method_config = std::move(*result);
-            MaybeAddCluster(
-                absl::StrCat("cluster:", cluster_name.cluster_name));
-          },
-          // WeightedClusters
-          [&](const std::vector<
-              XdsRouteConfigResource::Route::RouteAction::ClusterWeight>&
-                  weighted_clusters) {
-            uint32_t end = 0;
-            for (const auto& weighted_cluster : weighted_clusters) {
-              Route::ClusterWeightState cluster_weight_state;
-              auto result =
-                  CreateMethodConfig(route_entry.route, &weighted_cluster);
-              if (!result.ok()) {
-                *status = result.status();
-                return;
-              }
-              cluster_weight_state.method_config = std::move(*result);
-              end += weighted_cluster.weight;
-              cluster_weight_state.range_end = end;
-              cluster_weight_state.cluster = weighted_cluster.name;
-              route_entry.weighted_cluster_state.push_back(
-                  std::move(cluster_weight_state));
-              MaybeAddCluster(absl::StrCat("cluster:", weighted_cluster.name));
-            }
-          },
-          // ClusterSpecifierPlugin
-          [&](const XdsRouteConfigResource::Route::RouteAction::
-                  ClusterSpecifierPluginName& cluster_specifier_plugin_name) {
-            auto result = CreateMethodConfig(route_entry.route, nullptr);
-            if (!result.ok()) {
-              *status = result.status();
-              return;
-            }
-            route_entry.method_config = std::move(*result);
-            MaybeAddCluster(absl::StrCat(
-                "cluster_specifier_plugin:",
-                cluster_specifier_plugin_name.cluster_specifier_plugin_name));
-          });
-      if (!status->ok()) return;
-    }
-  }
-  // Populate filter list.
-  const auto& http_filter_registry =
-      static_cast<const GrpcXdsBootstrap&>(resolver_->xds_client_->bootstrap())
-          .http_filter_registry();
-  for (const auto& http_filter : resolver_->current_listener_.http_filters) {
-    // Find filter.  This is guaranteed to succeed, because it's checked
-    // at config validation time in the XdsApi code.
-    const XdsHttpFilterImpl* filter_impl =
-        http_filter_registry.GetFilterForType(
-            http_filter.config.config_proto_type_name);
-    GPR_ASSERT(filter_impl != nullptr);
-    // Add C-core filter to list.
-    if (filter_impl->channel_filter() != nullptr) {
-      filters_.push_back(filter_impl->channel_filter());
+  data->routes_.reserve(resolver->current_config_->virtual_host->routes.size());
+  for (auto& route : resolver->current_config_->virtual_host->routes) {
+    absl::Status status =
+        data->AddRouteEntry(resolver, route, default_max_stream_duration);
+    if (!status.ok()) {
+      return status;
     }
   }
+  return data;
 }
 
-XdsResolver::XdsConfigSelector::~XdsConfigSelector() {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
-    gpr_log(GPR_INFO, "[xds_resolver %p] destroying XdsConfigSelector %p",
-            resolver_.get(), this);
+XdsResolver::RouteConfigData::RouteEntry*
+XdsResolver::RouteConfigData::GetRouteForRequest(
+    absl::string_view path, grpc_metadata_batch* initial_metadata) {
+  auto route_index = XdsRouting::GetRouteForRequest(RouteListIterator(this),
+                                                    path, initial_metadata);
+  if (!route_index.has_value()) {
+    return nullptr;
   }
-  clusters_.clear();
-  resolver_->MaybeRemoveUnusedClusters();
+  return &routes_[*route_index];
 }
 
 absl::StatusOr<RefCountedPtr<ServiceConfig>>
-XdsResolver::XdsConfigSelector::CreateMethodConfig(
-    const XdsRouteConfigResource::Route& route,
+XdsResolver::RouteConfigData::CreateMethodConfig(
+    XdsResolver* resolver, const XdsRouteConfigResource::Route& route,
     const XdsRouteConfigResource::Route::RouteAction::ClusterWeight*
         cluster_weight) {
   std::vector<std::string> fields;
@@ -594,12 +503,13 @@ XdsResolver::XdsConfigSelector::CreateMethodConfig(
                         route_action.max_stream_duration->ToJsonString()));
   }
   // Handle xDS HTTP filters.
+  const auto& hcm = absl::get<XdsListenerResource::HttpConnectionManager>(
+      resolver->current_config_->listener->listener);
   auto result = XdsRouting::GeneratePerHTTPFilterConfigs(
-      static_cast<const GrpcXdsBootstrap&>(resolver_->xds_client_->bootstrap())
+      static_cast<const GrpcXdsBootstrap&>(resolver->xds_client_->bootstrap())
           .http_filter_registry(),
-      resolver_->current_listener_.http_filters,
-      resolver_->current_virtual_host_.value(), route, cluster_weight,
-      resolver_->args_);
+      hcm.http_filters, *resolver->current_config_->virtual_host, route,
+      cluster_weight, resolver->args_);
   if (!result.ok()) return result.status();
   for (const auto& p : result->per_filter_configs) {
     fields.emplace_back(absl::StrCat("    \"", p.first, "\": [\n",
@@ -623,16 +533,141 @@ XdsResolver::XdsConfigSelector::CreateMethodConfig(
   return nullptr;
 }
 
-void XdsResolver::XdsConfigSelector::MaybeAddCluster(const std::string& name) {
-  if (clusters_.find(name) == clusters_.end()) {
-    auto it = resolver_->cluster_state_map_.find(name);
-    if (it == resolver_->cluster_state_map_.end()) {
-      auto new_cluster_state = MakeRefCounted<ClusterState>(resolver_, name);
-      clusters_[new_cluster_state->cluster()] = std::move(new_cluster_state);
-    } else {
-      clusters_[it->second->cluster()] = it->second->Ref();
+absl::Status XdsResolver::RouteConfigData::AddRouteEntry(
+    XdsResolver* resolver, const XdsRouteConfigResource::Route& route,
+    const Duration& default_max_stream_duration) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+    gpr_log(GPR_INFO, "[xds_resolver %p] XdsConfigSelector %p: route: %s",
+            resolver, this, route.ToString().c_str());
+  }
+  routes_.emplace_back(route);
+  auto* route_entry = &routes_.back();
+  auto maybe_add_cluster = [&](absl::string_view cluster_key,
+                               absl::string_view cluster_name) {
+    if (clusters_.find(cluster_key) != clusters_.end()) return;
+    auto cluster_state =
+        resolver->GetOrCreateClusterRef(cluster_key, cluster_name);
+    absl::string_view key = cluster_state->cluster_key();
+    clusters_.emplace(key, std::move(cluster_state));
+  };
+  auto* route_action = absl::get_if<XdsRouteConfigResource::Route::RouteAction>(
+      &route_entry->route.action);
+  if (route_action != nullptr) {
+    // If the route doesn't specify a timeout, set its timeout to the global
+    // one.
+    if (!route_action->max_stream_duration.has_value()) {
+      route_action->max_stream_duration = default_max_stream_duration;
+    }
+    absl::Status status = Match(
+        route_action->action,
+        // cluster name
+        [&](const XdsRouteConfigResource::Route::RouteAction::ClusterName&
+                cluster_name) {
+          auto result =
+              CreateMethodConfig(resolver, route_entry->route, nullptr);
+          if (!result.ok()) {
+            return result.status();
+          }
+          route_entry->method_config = std::move(*result);
+          maybe_add_cluster(absl::StrCat("cluster:", cluster_name.cluster_name),
+                            cluster_name.cluster_name);
+          return absl::OkStatus();
+        },
+        // WeightedClusters
+        [&](const std::vector<
+            XdsRouteConfigResource::Route::RouteAction::ClusterWeight>&
+                weighted_clusters) {
+          uint32_t end = 0;
+          for (const auto& weighted_cluster : weighted_clusters) {
+            auto result = CreateMethodConfig(resolver, route_entry->route,
+                                             &weighted_cluster);
+            if (!result.ok()) {
+              return result.status();
+            }
+            RouteEntry::ClusterWeightState cluster_weight_state;
+            cluster_weight_state.method_config = std::move(*result);
+            end += weighted_cluster.weight;
+            cluster_weight_state.range_end = end;
+            cluster_weight_state.cluster = weighted_cluster.name;
+            route_entry->weighted_cluster_state.push_back(
+                std::move(cluster_weight_state));
+            maybe_add_cluster(absl::StrCat("cluster:", weighted_cluster.name),
+                              weighted_cluster.name);
+          }
+          return absl::OkStatus();
+        },
+        // ClusterSpecifierPlugin
+        [&](const XdsRouteConfigResource::Route::RouteAction::
+                ClusterSpecifierPluginName& cluster_specifier_plugin_name) {
+          auto result =
+              CreateMethodConfig(resolver, route_entry->route, nullptr);
+          if (!result.ok()) {
+            return result.status();
+          }
+          route_entry->method_config = std::move(*result);
+          maybe_add_cluster(
+              absl::StrCat(
+                  "cluster_specifier_plugin:",
+                  cluster_specifier_plugin_name.cluster_specifier_plugin_name),
+              /*subscription_name=*/"");
+          return absl::OkStatus();
+        });
+    if (!status.ok()) {
+      return status;
     }
   }
+  return absl::OkStatus();
+}
+
+//
+// XdsResolver::XdsConfigSelector
+//
+
+XdsResolver::XdsConfigSelector::XdsConfigSelector(
+    RefCountedPtr<XdsResolver> resolver,
+    RefCountedPtr<RouteConfigData> route_config_data)
+    : resolver_(std::move(resolver)),
+      route_config_data_(std::move(route_config_data)) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+    gpr_log(GPR_INFO, "[xds_resolver %p] creating XdsConfigSelector %p",
+            resolver_.get(), this);
+  }
+  // Populate filter list.
+  const auto& http_filter_registry =
+      static_cast<const GrpcXdsBootstrap&>(resolver_->xds_client_->bootstrap())
+          .http_filter_registry();
+  const auto& hcm = absl::get<XdsListenerResource::HttpConnectionManager>(
+      resolver_->current_config_->listener->listener);
+  for (const auto& http_filter : hcm.http_filters) {
+    // Find filter.  This is guaranteed to succeed, because it's checked
+    // at config validation time in the XdsApi code.
+    const XdsHttpFilterImpl* filter_impl =
+        http_filter_registry.GetFilterForType(
+            http_filter.config.config_proto_type_name);
+    GPR_ASSERT(filter_impl != nullptr);
+    // Add C-core filter to list.
+    if (filter_impl->channel_filter() != nullptr) {
+      filters_.push_back(filter_impl->channel_filter());
+    }
+  }
+  filters_.push_back(&ClusterSelectionFilter::kFilter);
+}
+
+XdsResolver::XdsConfigSelector::~XdsConfigSelector() {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
+    gpr_log(GPR_INFO, "[xds_resolver %p] destroying XdsConfigSelector %p",
+            resolver_.get(), this);
+  }
+  route_config_data_.reset();
+  if (!IsWorkSerializerDispatchEnabled()) {
+    resolver_->MaybeRemoveUnusedClusters();
+    return;
+  }
+  resolver_->work_serializer_->Run(
+      [resolver = std::move(resolver_)]() {
+        resolver->MaybeRemoveUnusedClusters();
+      },
+      DEBUG_LOCATION);
 }
 
 absl::optional<uint64_t> HeaderHashHelper(
@@ -656,22 +691,20 @@ absl::optional<uint64_t> HeaderHashHelper(
   return XXH64(header_value->data(), header_value->size(), 0);
 }
 
-absl::StatusOr<ConfigSelector::CallConfig>
-XdsResolver::XdsConfigSelector::GetCallConfig(GetCallConfigArgs args) {
+absl::Status XdsResolver::XdsConfigSelector::GetCallConfig(
+    GetCallConfigArgs args) {
   Slice* path = args.initial_metadata->get_pointer(HttpPathMetadata());
   GPR_ASSERT(path != nullptr);
-  auto route_index = XdsRouting::GetRouteForRequest(
-      RouteListIterator(&route_table_), path->as_string_view(),
-      args.initial_metadata);
-  if (!route_index.has_value()) {
+  auto* entry = route_config_data_->GetRouteForRequest(path->as_string_view(),
+                                                       args.initial_metadata);
+  if (entry == nullptr) {
     return absl::UnavailableError(
         "No matching route found in xDS route config");
   }
-  auto& entry = route_table_[*route_index];
   // Found a route match
   const auto* route_action =
       absl::get_if<XdsRouteConfigResource::Route::RouteAction>(
-          &entry.route.action);
+          &entry->route.action);
   if (route_action == nullptr) {
     return absl::UnavailableError("Matching route has inappropriate action");
   }
@@ -684,24 +717,24 @@ XdsResolver::XdsConfigSelector::GetCallConfig(GetCallConfigArgs args) {
               action_cluster_name) {
         cluster_name =
             absl::StrCat("cluster:", action_cluster_name.cluster_name);
-        method_config = entry.method_config;
+        method_config = entry->method_config;
       },
       // WeightedClusters
       [&](const std::vector<
           XdsRouteConfigResource::Route::RouteAction::ClusterWeight>&
           /*weighted_clusters*/) {
         const uint32_t key = absl::Uniform<uint32_t>(
-            absl::BitGen(), 0, entry.weighted_cluster_state.back().range_end);
+            absl::BitGen(), 0, entry->weighted_cluster_state.back().range_end);
         // Find the index in weighted clusters corresponding to key.
         size_t mid = 0;
         size_t start_index = 0;
-        size_t end_index = entry.weighted_cluster_state.size() - 1;
+        size_t end_index = entry->weighted_cluster_state.size() - 1;
         size_t index = 0;
         while (end_index > start_index) {
           mid = (start_index + end_index) / 2;
-          if (entry.weighted_cluster_state[mid].range_end > key) {
+          if (entry->weighted_cluster_state[mid].range_end > key) {
             end_index = mid;
-          } else if (entry.weighted_cluster_state[mid].range_end < key) {
+          } else if (entry->weighted_cluster_state[mid].range_end < key) {
             start_index = mid + 1;
           } else {
             index = mid + 1;
@@ -709,10 +742,10 @@ XdsResolver::XdsConfigSelector::GetCallConfig(GetCallConfigArgs args) {
           }
         }
         if (index == 0) index = start_index;
-        GPR_ASSERT(entry.weighted_cluster_state[index].range_end > key);
+        GPR_ASSERT(entry->weighted_cluster_state[index].range_end > key);
         cluster_name = absl::StrCat(
-            "cluster:", entry.weighted_cluster_state[index].cluster);
-        method_config = entry.weighted_cluster_state[index].method_config;
+            "cluster:", entry->weighted_cluster_state[index].cluster);
+        method_config = entry->weighted_cluster_state[index].method_config;
       },
       // ClusterSpecifierPlugin
       [&](const XdsRouteConfigResource::Route::RouteAction::
@@ -720,10 +753,10 @@ XdsResolver::XdsConfigSelector::GetCallConfig(GetCallConfigArgs args) {
         cluster_name = absl::StrCat(
             "cluster_specifier_plugin:",
             cluster_specifier_plugin_name.cluster_specifier_plugin_name);
-        method_config = entry.method_config;
+        method_config = entry->method_config;
       });
-  auto it = clusters_.find(cluster_name);
-  GPR_ASSERT(it != clusters_.end());
+  auto cluster = route_config_data_->FindClusterRef(cluster_name);
+  GPR_ASSERT(cluster != nullptr);
   // Generate a hash.
   absl::optional<uint64_t> hash;
   for (const auto& hash_policy : route_action->hash_policies) {
@@ -735,14 +768,14 @@ XdsResolver::XdsConfigSelector::GetCallConfig(GetCallConfigArgs args) {
         },
         [&](const XdsRouteConfigResource::Route::RouteAction::HashPolicy::
                 ChannelId&) -> absl::optional<uint64_t> {
-          return resolver_->channel_id();
+          return resolver_->channel_id_;
         });
     if (new_hash.has_value()) {
       // Rotating the old value prevents duplicate hash rules from cancelling
       // each other out and preserves all of the entropy
       const uint64_t old_value =
-          hash.has_value() ? ((hash.value() << 1) | (hash.value() >> 63)) : 0;
-      hash = old_value ^ new_hash.value();
+          hash.has_value() ? ((*hash << 1) | (*hash >> 63)) : 0;
+      hash = old_value ^ *new_hash;
     }
     // If the policy is a terminal policy and a hash has been generated,
     // ignore the rest of the hash policies.
@@ -753,22 +786,93 @@ XdsResolver::XdsConfigSelector::GetCallConfig(GetCallConfigArgs args) {
   if (!hash.has_value()) {
     hash = absl::Uniform<uint64_t>(absl::BitGen());
   }
-  CallConfig call_config;
+  // Populate service config call data.
   if (method_config != nullptr) {
-    call_config.method_configs =
+    auto* parsed_method_configs =
         method_config->GetMethodParsedConfigVector(grpc_empty_slice());
-    call_config.service_config = std::move(method_config);
+    args.service_config_call_data->SetServiceConfig(std::move(method_config),
+                                                    parsed_method_configs);
+  }
+  args.service_config_call_data->SetCallAttribute(
+      args.arena->New<XdsClusterAttribute>(cluster->cluster_key()));
+  args.service_config_call_data->SetCallAttribute(
+      args.arena->New<RequestHashAttribute>(*hash));
+  args.service_config_call_data->SetCallAttribute(
+      args.arena->ManagedNew<XdsRouteStateAttributeImpl>(route_config_data_,
+                                                         entry));
+  return absl::OkStatus();
+}
+
+//
+// XdsResolver::XdsRouteStateAttributeImpl
+//
+
+bool XdsResolver::XdsRouteStateAttributeImpl::HasClusterForRoute(
+    absl::string_view cluster_name) const {
+  // Found a route match
+  const auto* route_action =
+      absl::get_if<XdsRouteConfigResource::Route::RouteAction>(
+          &static_cast<RouteConfigData::RouteEntry*>(route_)->route.action);
+  if (route_action == nullptr) return false;
+  return Match(
+      route_action->action,
+      [&](const XdsRouteConfigResource::Route::RouteAction::ClusterName& name) {
+        return name.cluster_name == cluster_name;
+      },
+      [&](const std::vector<
+          XdsRouteConfigResource::Route::RouteAction::ClusterWeight>&
+              clusters) {
+        for (const auto& cluster : clusters) {
+          if (cluster.name == cluster_name) {
+            return true;
+          }
+        }
+        return false;
+      },
+      [&](const XdsRouteConfigResource::Route::RouteAction::
+              ClusterSpecifierPluginName& /* name */) { return false; });
+}
+
+RefCountedPtr<XdsResolver::ClusterRef>
+XdsResolver::XdsRouteStateAttributeImpl::LockAndGetCluster(
+    absl::string_view cluster_name) {
+  if (route_config_data_ == nullptr) {
+    return nullptr;
+  }
+  auto cluster = route_config_data_->FindClusterRef(cluster_name);
+  route_config_data_.reset();
+  return cluster;
+}
+
+//
+// XdsResolver::ClusterSelectionFilter
+//
+
+const grpc_channel_filter XdsResolver::ClusterSelectionFilter::kFilter =
+    MakePromiseBasedFilter<ClusterSelectionFilter, FilterEndpoint::kClient,
+                           kFilterExaminesServerInitialMetadata>(
+        "cluster_selection_filter");
+
+void XdsResolver::ClusterSelectionFilter::Call::OnClientInitialMetadata(
+    ClientMetadata&) {
+  auto* service_config_call_data =
+      static_cast<ClientChannelServiceConfigCallData*>(
+          GetContext<grpc_call_context_element>()
+              [GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA]
+                  .value);
+  GPR_ASSERT(service_config_call_data != nullptr);
+  auto* route_state_attribute = static_cast<XdsRouteStateAttributeImpl*>(
+      service_config_call_data->GetCallAttribute<XdsRouteStateAttribute>());
+  auto* cluster_name_attribute =
+      service_config_call_data->GetCallAttribute<XdsClusterAttribute>();
+  if (route_state_attribute != nullptr && cluster_name_attribute != nullptr) {
+    auto cluster = route_state_attribute->LockAndGetCluster(
+        cluster_name_attribute->cluster());
+    if (cluster != nullptr) {
+      service_config_call_data->SetOnCommit(
+          [cluster = std::move(cluster)]() mutable { cluster.reset(); });
+    }
   }
-  call_config.call_attributes[XdsClusterAttributeTypeName()] = it->first;
-  std::string hash_string = absl::StrCat(hash.value());
-  char* hash_value =
-      static_cast<char*>(args.arena->Alloc(hash_string.size() + 1));
-  memcpy(hash_value, hash_string.c_str(), hash_string.size());
-  hash_value[hash_string.size()] = '\0';
-  call_config.call_attributes[RequestHashAttributeName()] = hash_value;
-  call_config.call_dispatch_controller =
-      args.arena->New<XdsCallDispatchController>(it->second->Ref());
-  return call_config;
 }
 
 //
@@ -792,6 +896,9 @@ void XdsResolver::StartLocked() {
     return;
   }
   xds_client_ = std::move(*xds_client);
+  grpc_pollset_set_add_pollset_set(xds_client_->interested_parties(),
+                                   interested_parties_);
+  // Determine LDS resource name.
   std::string resource_name_fragment(absl::StripPrefix(uri_.path(), "/"));
   if (!uri_.authority().empty()) {
     // target_uri.authority is set case
@@ -837,13 +944,11 @@ void XdsResolver::StartLocked() {
     gpr_log(GPR_INFO, "[xds_resolver %p] Started with lds_resource_name %s.",
             this, lds_resource_name_.c_str());
   }
-  grpc_pollset_set_add_pollset_set(
-      static_cast<GrpcXdsClient*>(xds_client_.get())->interested_parties(),
-      interested_parties_);
-  auto watcher = MakeRefCounted<ListenerWatcher>(Ref());
-  listener_watcher_ = watcher.get();
-  XdsListenerResourceType::StartWatch(xds_client_.get(), lds_resource_name_,
-                                      std::move(watcher));
+  // Start watch for xDS config.
+  dependency_mgr_ = MakeOrphanable<XdsDependencyManager>(
+      xds_client_, work_serializer_,
+      std::make_unique<XdsWatcher>(RefAsSubclass<XdsResolver>()),
+      data_plane_authority_, lds_resource_name_, args_, interested_parties_);
 }
 
 void XdsResolver::ShutdownLocked() {
@@ -851,124 +956,20 @@ void XdsResolver::ShutdownLocked() {
     gpr_log(GPR_INFO, "[xds_resolver %p] shutting down", this);
   }
   if (xds_client_ != nullptr) {
-    if (listener_watcher_ != nullptr) {
-      XdsListenerResourceType::CancelWatch(
-          xds_client_.get(), lds_resource_name_, listener_watcher_,
-          /*delay_unsubscription=*/false);
-    }
-    if (route_config_watcher_ != nullptr) {
-      XdsRouteConfigResourceType::CancelWatch(
-          xds_client_.get(), route_config_name_, route_config_watcher_,
-          /*delay_unsubscription=*/false);
-    }
-    grpc_pollset_set_del_pollset_set(
-        static_cast<GrpcXdsClient*>(xds_client_.get())->interested_parties(),
-        interested_parties_);
+    dependency_mgr_.reset();
+    grpc_pollset_set_del_pollset_set(xds_client_->interested_parties(),
+                                     interested_parties_);
     xds_client_.reset(DEBUG_LOCATION, "xds resolver");
   }
 }
 
-void XdsResolver::OnListenerUpdate(XdsListenerResource listener) {
+void XdsResolver::OnUpdate(
+    RefCountedPtr<const XdsDependencyManager::XdsConfig> config) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
-    gpr_log(GPR_INFO, "[xds_resolver %p] received updated listener data", this);
+    gpr_log(GPR_INFO, "[xds_resolver %p] received updated xDS config", this);
   }
   if (xds_client_ == nullptr) return;
-  auto* hcm = absl::get_if<XdsListenerResource::HttpConnectionManager>(
-      &listener.listener);
-  if (hcm == nullptr) {
-    return OnError(lds_resource_name_,
-                   absl::UnavailableError("not an API listener"));
-  }
-  current_listener_ = std::move(*hcm);
-  MatchMutable(
-      &current_listener_.route_config,
-      // RDS resource name
-      [&](std::string* rds_name) {
-        // If the RDS name changed, update the RDS watcher.
-        // Note that this will be true on the initial update, because
-        // route_config_name_ will be empty.
-        if (route_config_name_ != *rds_name) {
-          // If we already had a watch (i.e., if the previous config had
-          // a different RDS name), stop the previous watch.
-          // There will be no previous watch if either (a) this is the
-          // initial resource update or (b) the previous Listener had an
-          // inlined RouteConfig.
-          if (route_config_watcher_ != nullptr) {
-            XdsRouteConfigResourceType::CancelWatch(
-                xds_client_.get(), route_config_name_, route_config_watcher_,
-                /*delay_unsubscription=*/true);
-            route_config_watcher_ = nullptr;
-          }
-          // Start watch for the new RDS resource name.
-          route_config_name_ = std::move(*rds_name);
-          auto watcher = MakeRefCounted<RouteConfigWatcher>(Ref());
-          route_config_watcher_ = watcher.get();
-          XdsRouteConfigResourceType::StartWatch(
-              xds_client_.get(), route_config_name_, std::move(watcher));
-        } else {
-          // RDS resource name has not changed, so no watch needs to be
-          // updated, but we still need to propagate any changes in the
-          // HCM config (e.g., the list of HTTP filters).
-          GenerateResult();
-        }
-      },
-      // inlined RouteConfig
-      [&](XdsRouteConfigResource* route_config) {
-        // If the previous update specified an RDS resource instead of
-        // having an inlined RouteConfig, we need to cancel the RDS watch.
-        if (route_config_watcher_ != nullptr) {
-          XdsRouteConfigResourceType::CancelWatch(
-              xds_client_.get(), route_config_name_, route_config_watcher_);
-          route_config_watcher_ = nullptr;
-          route_config_name_.clear();
-        }
-        OnRouteConfigUpdate(std::move(*route_config));
-      });
-}
-
-namespace {
-class VirtualHostListIterator : public XdsRouting::VirtualHostListIterator {
- public:
-  explicit VirtualHostListIterator(
-      const std::vector<XdsRouteConfigResource::VirtualHost>* virtual_hosts)
-      : virtual_hosts_(virtual_hosts) {}
-
-  size_t Size() const override { return virtual_hosts_->size(); }
-
-  const std::vector<std::string>& GetDomainsForVirtualHost(
-      size_t index) const override {
-    return (*virtual_hosts_)[index].domains;
-  }
-
- private:
-  const std::vector<XdsRouteConfigResource::VirtualHost>* virtual_hosts_;
-};
-}  // namespace
-
-void XdsResolver::OnRouteConfigUpdate(XdsRouteConfigResource rds_update) {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_resolver_trace)) {
-    gpr_log(GPR_INFO, "[xds_resolver %p] received updated route config", this);
-  }
-  if (xds_client_ == nullptr) {
-    return;
-  }
-  // Find the relevant VirtualHost from the RouteConfiguration.
-  auto vhost_index = XdsRouting::FindVirtualHostForDomain(
-      VirtualHostListIterator(&rds_update.virtual_hosts),
-      data_plane_authority_);
-  if (!vhost_index.has_value()) {
-    OnError(
-        route_config_name_.empty() ? lds_resource_name_ : route_config_name_,
-        absl::UnavailableError(absl::StrCat("could not find VirtualHost for ",
-                                            data_plane_authority_,
-                                            " in RouteConfiguration")));
-    return;
-  }
-  // Save the virtual host in the resolver.
-  current_virtual_host_ = std::move(rds_update.virtual_hosts[*vhost_index]);
-  cluster_specifier_plugin_map_ =
-      std::move(rds_update.cluster_specifier_plugin_map);
-  // Send a new result to the channel.
+  current_config_ = std::move(config);
   GenerateResult();
 }
 
@@ -981,11 +982,8 @@ void XdsResolver::OnError(absl::string_view context, absl::Status status) {
   Result result;
   result.addresses = status;
   result.service_config = std::move(status);
-  // Need to explicitly convert to the right RefCountedPtr<> type for
-  // use with ChannelArgs::SetObject().
-  RefCountedPtr<GrpcXdsClient> xds_client =
-      xds_client_->Ref(DEBUG_LOCATION, "xds resolver result");
-  result.args = args_.SetObject(std::move(xds_client));
+  result.args =
+      args_.SetObject(xds_client_.Ref(DEBUG_LOCATION, "xds resolver result"));
   result_handler_->ReportResult(std::move(result));
 }
 
@@ -994,10 +992,8 @@ void XdsResolver::OnResourceDoesNotExist(std::string context) {
           "[xds_resolver %p] LDS/RDS resource does not exist -- clearing "
           "update and returning empty service config",
           this);
-  if (xds_client_ == nullptr) {
-    return;
-  }
-  current_virtual_host_.reset();
+  if (xds_client_ == nullptr) return;
+  current_config_.reset();
   Result result;
   result.addresses.emplace();
   result.service_config = ServiceConfigImpl::Create(args_, "{}");
@@ -1010,7 +1006,7 @@ void XdsResolver::OnResourceDoesNotExist(std::string context) {
 absl::StatusOr<RefCountedPtr<ServiceConfig>>
 XdsResolver::CreateServiceConfig() {
   std::vector<std::string> clusters;
-  for (const auto& cluster : cluster_state_map_) {
+  for (const auto& cluster : cluster_ref_map_) {
     absl::string_view child_name = cluster.first;
     if (absl::ConsumePrefix(&child_name, "cluster_specifier_plugin:")) {
       clusters.push_back(absl::StrFormat(
@@ -1018,7 +1014,8 @@ XdsResolver::CreateServiceConfig() {
           "        \"childPolicy\": %s\n"
           "       }",
           cluster.first,
-          cluster_specifier_plugin_map_[std::string(child_name)]));
+          current_config_->route_config->cluster_specifier_plugin_map.at(
+              std::string(child_name))));
     } else {
       absl::ConsumePrefix(&child_name, "cluster:");
       clusters.push_back(
@@ -1049,16 +1046,21 @@ XdsResolver::CreateServiceConfig() {
 }
 
 void XdsResolver::GenerateResult() {
-  if (!current_virtual_host_.has_value()) return;
+  if (xds_client_ == nullptr || current_config_ == nullptr) return;
   // First create XdsConfigSelector, which may add new entries to the cluster
-  // state map, and then CreateServiceConfig for LB policies.
-  absl::Status status;
-  auto config_selector = MakeRefCounted<XdsConfigSelector>(Ref(), &status);
-  if (!status.ok()) {
+  // state map.
+  const auto& hcm = absl::get<XdsListenerResource::HttpConnectionManager>(
+      current_config_->listener->listener);
+  auto route_config_data =
+      RouteConfigData::Create(this, hcm.http_max_stream_duration);
+  if (!route_config_data.ok()) {
     OnError("could not create ConfigSelector",
-            absl::UnavailableError(status.message()));
+            absl::UnavailableError(route_config_data.status().message()));
     return;
   }
+  auto config_selector = MakeRefCounted<XdsConfigSelector>(
+      RefAsSubclass<XdsResolver>(), std::move(*route_config_data));
+  // Now create the service config.
   Result result;
   result.addresses.emplace();
   result.service_config = CreateServiceConfig();
@@ -1068,34 +1070,30 @@ void XdsResolver::GenerateResult() {
                 ? std::string((*result.service_config)->json_string()).c_str()
                 : result.service_config.status().ToString().c_str());
   }
-  // Need to explicitly convert to the right RefCountedPtr<> type for
-  // use with ChannelArgs::SetObject().
-  RefCountedPtr<GrpcXdsClient> xds_client =
-      xds_client_->Ref(DEBUG_LOCATION, "xds resolver result");
   result.args =
-      args_.SetObject(std::move(xds_client)).SetObject(config_selector);
+      args_.SetObject(xds_client_.Ref(DEBUG_LOCATION, "xds resolver result"))
+          .SetObject(config_selector)
+          .SetObject(current_config_)
+          .SetObject(dependency_mgr_->Ref());
   result_handler_->ReportResult(std::move(result));
 }
 
 void XdsResolver::MaybeRemoveUnusedClusters() {
   bool update_needed = false;
-  for (auto it = cluster_state_map_.begin(); it != cluster_state_map_.end();) {
-    RefCountedPtr<ClusterState> cluster_state = it->second->RefIfNonZero();
+  for (auto it = cluster_ref_map_.begin(); it != cluster_ref_map_.end();) {
+    RefCountedPtr<ClusterRef> cluster_state = it->second->RefIfNonZero();
     if (cluster_state != nullptr) {
       ++it;
     } else {
       update_needed = true;
-      it = cluster_state_map_.erase(it);
+      it = cluster_ref_map_.erase(it);
     }
   }
-  if (update_needed && xds_client_ != nullptr) {
-    // Send a new result to the channel.
-    GenerateResult();
-  }
+  if (update_needed) GenerateResult();
 }
 
 //
-// Factory
+// XdsResolverFactory
 //
 
 class XdsResolverFactory : public ResolverFactory {
@@ -1111,13 +1109,19 @@ class XdsResolverFactory : public ResolverFactory {
     return true;
   }
 
-  std::string GetDefaultAuthority(const URI& uri) const override {
-    return GetDefaultAuthorityInternal(uri);
-  }
-
   OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
     if (!IsValidUri(args.uri)) return nullptr;
-    return MakeOrphanable<XdsResolver>(std::move(args));
+    std::string authority = GetDataPlaneAuthority(args.args, args.uri);
+    return MakeOrphanable<XdsResolver>(std::move(args), std::move(authority));
+  }
+
+ private:
+  std::string GetDataPlaneAuthority(const ChannelArgs& args,
+                                    const URI& uri) const {
+    absl::optional<absl::string_view> authority =
+        args.GetString(GRPC_ARG_DEFAULT_AUTHORITY);
+    if (authority.has_value()) return URI::PercentEncodeAuthority(*authority);
+    return GetDefaultAuthority(uri);
   }
 };