grpc 1.46.2 → 1.48.0.pre1

data/src/core/ext/xds/xds_client.cc

@@ -22,45 +22,62 @@
 #include <limits.h>
 #include <string.h>
 
+#include <algorithm>
+
 #include "absl/container/inlined_vector.h"
+#include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
+#include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
+#include "absl/strings/strip.h"
 
+#include <grpc/byte_buffer.h>
 #include <grpc/byte_buffer_reader.h>
 #include <grpc/grpc.h>
+#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/impl/codegen/propagation_bits.h>
+#include <grpc/slice.h>
+#include <grpc/status.h>
 #include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
+#include "src/core/ext/xds/upb_utils.h"
 #include "src/core/ext/xds/xds_api.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_channel_args.h"
 #include "src/core/ext/xds/xds_client_stats.h"
-#include "src/core/ext/xds/xds_cluster.h"
 #include "src/core/ext/xds/xds_cluster_specifier_plugin.h"
-#include "src/core/ext/xds/xds_endpoint.h"
 #include "src/core/ext/xds/xds_http_filters.h"
-#include "src/core/ext/xds/xds_listener.h"
-#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gpr/env.h"
-#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/iomgr/sockaddr.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/load_file.h"
+#include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/security/credentials/channel_creds_registry.h"
+#include "src/core/lib/security/credentials/credentials.h"
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
-#include "src/core/lib/slice/slice_string_helpers.h"
+#include "src/core/lib/slice/slice_refcount.h"
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/surface/lame_client.h"
+#include "src/core/lib/transport/connectivity_state.h"
 #include "src/core/lib/uri/uri_parser.h"
 
 #define GRPC_XDS_INITIAL_CONNECT_BACKOFF_SECONDS 1
@@ -198,9 +215,20 @@ class XdsClient::ChannelState::AdsCallState
       Unref(DEBUG_LOCATION, "Orphan");
     }
 
-    void MaybeStartTimer(RefCountedPtr<AdsCallState> ads_calld) {
-      if (timer_started_) return;
-      timer_started_ = true;
+    void MaybeStartTimer(RefCountedPtr<AdsCallState> ads_calld)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_) {
+      if (!timer_start_needed_) return;
+      timer_start_needed_ = false;
+      // Check if we already have a cached version of this resource
+      // (i.e., if this is the initial request for the resource after an
+      // ADS stream restart).  If so, we don't start the timer, because
+      // (a) we already have the resource and (b) the server may
+      // optimize by not resending the resource that we already have.
+      auto& authority_state =
+          ads_calld->xds_client()->authority_state_map_[name_.authority];
+      ResourceState& state = authority_state.resource_map[type_][name_.key];
+      if (state.resource != nullptr) return;
+      // Start timer.
       ads_calld_ = std::move(ads_calld);
       Ref(DEBUG_LOCATION, "timer").release();
       timer_pending_ = true;
@@ -211,6 +239,18 @@ class XdsClient::ChannelState::AdsCallState
     }
 
     void MaybeCancelTimer() {
+      // If the timer hasn't been started yet, make sure we don't start
+      // it later.  This can happen if the last watch for an LDS or CDS
+      // resource is cancelled and then restarted, both while an ADS
+      // request for a different resource type is being sent (causing
+      // the unsubscription and then resubscription requests to be
+      // queued), and then we get a response for the LDS or CDS resource.
+      // In that case, we would call MaybeCancelTimer() when we receive the
+      // response and then MaybeStartTimer() when we finally send the new
+      // LDS or CDS request, thus causing the timer to fire when it shouldn't.
+      // For details, see https://github.com/grpc/grpc/issues/29583.
+      // TODO(roth): Find a way to write a test for this case.
+      timer_start_needed_ = false;
       if (timer_pending_) {
         grpc_timer_cancel(&timer_);
         timer_pending_ = false;
@@ -231,25 +271,25 @@ class XdsClient::ChannelState::AdsCallState
 
     void OnTimerLocked(grpc_error_handle error)
         ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_) {
-      if (error == GRPC_ERROR_NONE && timer_pending_) {
+      if (GRPC_ERROR_IS_NONE(error) && timer_pending_) {
         timer_pending_ = false;
-        absl::Status watcher_error = absl::UnavailableError(absl::StrFormat(
-            "timeout obtaining resource {type=%s name=%s} from xds server",
-            type_->type_url(),
-            XdsClient::ConstructFullXdsResourceName(
-                name_.authority, type_->type_url(), name_.key)));
         if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
-          gpr_log(GPR_INFO, "[xds_client %p] xds server %s: %s",
+          gpr_log(GPR_INFO,
+                  "[xds_client %p] xds server %s: timeout obtaining resource "
+                  "{type=%s name=%s} from xds server",
                   ads_calld_->xds_client(),
                   ads_calld_->chand()->server_.server_uri.c_str(),
-                  watcher_error.ToString().c_str());
+                  std::string(type_->type_url()).c_str(),
+                  XdsClient::ConstructFullXdsResourceName(
+                      name_.authority, type_->type_url(), name_.key)
+                      .c_str());
         }
         auto& authority_state =
             ads_calld_->xds_client()->authority_state_map_[name_.authority];
         ResourceState& state = authority_state.resource_map[type_][name_.key];
         state.meta.client_status = XdsApi::ResourceMetadata::DOES_NOT_EXIST;
-        ads_calld_->xds_client()->NotifyWatchersOnErrorLocked(state.watchers,
-                                                              watcher_error);
+        ads_calld_->xds_client()->NotifyWatchersOnResourceDoesNotExist(
+            state.watchers);
       }
       GRPC_ERROR_UNREF(error);
     }
@@ -258,7 +298,7 @@ class XdsClient::ChannelState::AdsCallState
     const XdsResourceName name_;
 
     RefCountedPtr<AdsCallState> ads_calld_;
-    bool timer_started_ = false;
+    bool timer_start_needed_ = true;
     bool timer_pending_ = false;
     grpc_timer timer_;
     grpc_closure timer_callback_;
@@ -294,7 +334,8 @@ class XdsClient::ChannelState::AdsCallState
 
   // Constructs a list of resource names of a given type for an ADS
   // request.  Also starts the timer for each resource if needed.
-  std::vector<std::string> ResourceNamesForRequest(const XdsResourceType* type);
+  std::vector<std::string> ResourceNamesForRequest(const XdsResourceType* type)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&XdsClient::mu_);
 
   // The owning RetryableCall<>.
   RefCountedPtr<RetryableCall<AdsCallState>> parent_;
@@ -555,7 +596,7 @@ namespace {
 bool IsLameChannel(grpc_channel* channel) {
   grpc_channel_element* elem =
       grpc_channel_stack_last_element(grpc_channel_get_channel_stack(channel));
-  return elem->filter == &grpc_lame_filter;
+  return elem->filter == &LameClientFilter::kFilter;
 }
 
 }  // namespace
@@ -566,7 +607,8 @@ void XdsClient::ChannelState::StartConnectivityWatchLocked() {
         absl::UnavailableError("xds client has a lame channel"));
     return;
   }
-  ClientChannel* client_channel = ClientChannel::GetFromChannel(channel_);
+  ClientChannel* client_channel =
+      ClientChannel::GetFromChannel(Channel::FromC(channel_));
   GPR_ASSERT(client_channel != nullptr);
   watcher_ = new StateWatcher(WeakRef(DEBUG_LOCATION, "ChannelState+watch"));
   client_channel->AddConnectivityWatcher(
@@ -578,7 +620,8 @@ void XdsClient::ChannelState::CancelConnectivityWatchLocked() {
   if (IsLameChannel(channel_)) {
     return;
   }
-  ClientChannel* client_channel = ClientChannel::GetFromChannel(channel_);
+  ClientChannel* client_channel =
+      ClientChannel::GetFromChannel(Channel::FromC(channel_));
   GPR_ASSERT(client_channel != nullptr);
   client_channel->RemoveConnectivityWatcher(watcher_);
 }
@@ -701,7 +744,7 @@ template <typename T>
 void XdsClient::ChannelState::RetryableCall<T>::OnRetryTimerLocked(
     grpc_error_handle error) {
   retry_timer_callback_pending_ = false;
-  if (!shutting_down_ && error == GRPC_ERROR_NONE) {
+  if (!shutting_down_ && GRPC_ERROR_IS_NONE(error)) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
       gpr_log(GPR_INFO,
               "[xds_client %p] xds server %s: retry timer fired (retryable "
@@ -788,7 +831,7 @@ void XdsClient::ChannelState::AdsCallState::AdsResponseParser::ParseResource(
   }
   // Check the resource name.
   auto resource_name =
-      XdsClient::ParseXdsResourceName(result->name, result_.type);
+      xds_client()->ParseXdsResourceName(result->name, result_.type);
   if (!resource_name.ok()) {
     result_.errors.emplace_back(absl::StrCat(
         "resource index ", idx, ": Cannot parse xDS resource name \"",
@@ -830,6 +873,17 @@ void XdsClient::ChannelState::AdsCallState::AdsResponseParser::ParseResource(
   if (result_.type->AllResourcesRequiredInSotW()) {
     result_.resources_seen[resource_name->authority].insert(resource_name->key);
   }
+  // If we previously ignored the resource's deletion, log that we're
+  // now re-adding it.
+  if (resource_state.ignored_deletion) {
+    gpr_log(GPR_INFO,
+            "[xds_client %p] xds server %s: server returned new version of "
+            "resource for which we previously ignored a deletion: type %s "
+            "name %s",
+            xds_client(), ads_call_state_->chand()->server_.server_uri.c_str(),
+            std::string(type_url).c_str(), result->name.c_str());
+    resource_state.ignored_deletion = false;
+  }
   // Update resource state based on whether the resource is valid.
   if (!result->resource.ok()) {
     result_.errors.emplace_back(absl::StrCat(
@@ -1100,7 +1154,7 @@ void XdsClient::ChannelState::AdsCallState::OnRequestSent(
 
 void XdsClient::ChannelState::AdsCallState::OnRequestSentLocked(
     grpc_error_handle error) {
-  if (IsCurrentCallOnChannel() && error == GRPC_ERROR_NONE) {
+  if (IsCurrentCallOnChannel() && GRPC_ERROR_IS_NONE(error)) {
     // Clean up the sent message.
     grpc_byte_buffer_destroy(send_message_payload_);
     send_message_payload_ = nullptr;
@@ -1205,9 +1259,23 @@ bool XdsClient::ChannelState::AdsCallState::OnResponseReceivedLocked() {
             // does not exist.  For that case, we rely on the request timeout
             // instead.
             if (resource_state.resource == nullptr) continue;
-            resource_state.resource.reset();
-            xds_client()->NotifyWatchersOnResourceDoesNotExist(
-                resource_state.watchers);
+            if (chand()->server_.IgnoreResourceDeletion()) {
+              if (!resource_state.ignored_deletion) {
+                gpr_log(GPR_ERROR,
+                        "[xds_client %p] xds server %s: ignoring deletion "
+                        "for resource type %s name %s",
+                        xds_client(), chand()->server_.server_uri.c_str(),
+                        result.type_url.c_str(),
+                        XdsClient::ConstructFullXdsResourceName(
+                            authority, result.type_url.c_str(), resource_key)
+                            .c_str());
+                resource_state.ignored_deletion = true;
+              }
+            } else {
+              resource_state.resource.reset();
+              xds_client()->NotifyWatchersOnResourceDoesNotExist(
+                  resource_state.watchers);
+            }
           }
         }
       }
@@ -1339,7 +1407,7 @@ void XdsClient::ChannelState::LrsCallState::Reporter::OnNextReportTimer(
 bool XdsClient::ChannelState::LrsCallState::Reporter::OnNextReportTimerLocked(
     grpc_error_handle error) {
   next_report_timer_callback_pending_ = false;
-  if (error != GRPC_ERROR_NONE || !IsCurrentReporterOnCall()) {
+  if (!GRPC_ERROR_IS_NONE(error) || !IsCurrentReporterOnCall()) {
     GRPC_ERROR_UNREF(error);
     return true;
   }
@@ -1431,7 +1499,7 @@ bool XdsClient::ChannelState::LrsCallState::Reporter::OnReportDoneLocked(
     GRPC_ERROR_UNREF(error);
     return true;
   }
-  if (error != GRPC_ERROR_NONE || !IsCurrentReporterOnCall()) {
+  if (!GRPC_ERROR_IS_NONE(error) || !IsCurrentReporterOnCall()) {
     GRPC_ERROR_UNREF(error);
     // If this reporter is no longer the current one on the call, the reason
     // might be that it was orphaned for a new one due to config update.
@@ -1641,7 +1709,7 @@ bool XdsClient::ChannelState::LrsCallState::OnResponseReceivedLocked() {
     grpc_error_handle parse_error = xds_client()->api_.ParseLrsResponse(
         response_slice, &send_all_clusters, &new_cluster_names,
         &new_load_reporting_interval);
-    if (parse_error != GRPC_ERROR_NONE) {
+    if (!GRPC_ERROR_IS_NONE(parse_error)) {
       gpr_log(GPR_ERROR,
               "[xds_client %p] xds server %s: LRS response parsing failed: %s",
               xds_client(), chand()->server_.server_uri.c_str(),
@@ -1788,6 +1856,7 @@ XdsClient::XdsClient(std::unique_ptr<XdsBootstrap> bootstrap,
       bootstrap_(std::move(bootstrap)),
       args_(ModifyChannelArgs(args)),
       request_timeout_(GetRequestTimeout(args)),
+      xds_federation_enabled_(XdsFederationEnabled()),
       interested_parties_(grpc_pollset_set_create()),
       certificate_provider_store_(MakeOrphanable<CertificateProviderStore>(
           bootstrap_->certificate_providers())),
@@ -1924,12 +1993,11 @@ void XdsClient::CancelResourceWatch(const XdsResourceType* type,
                                     bool delay_unsubscription) {
   auto resource_name = ParseXdsResourceName(name, type);
   MutexLock lock(&mu_);
-  if (!resource_name.ok()) {
-    invalid_watchers_.erase(watcher);
-    return;
-  }
-  if (shutting_down_) return;
+  // We cannot be sure whether the watcher is in invalid_watchers_ or in
+  // authority_state_map_, so we check both, just to be safe.
+  invalid_watchers_.erase(watcher);
   // Find authority.
+  if (!resource_name.ok()) return;
   auto authority_it = authority_state_map_.find(resource_name->authority);
   if (authority_it == authority_state_map_.end()) return;
   AuthorityState& authority_state = authority_it->second;
@@ -1945,6 +2013,13 @@ void XdsClient::CancelResourceWatch(const XdsResourceType* type,
   resource_state.watchers.erase(watcher);
   // Clean up empty map entries, if any.
   if (resource_state.watchers.empty()) {
+    if (resource_state.ignored_deletion) {
+      gpr_log(GPR_INFO,
+              "[xds_client %p] unsubscribing from a resource for which we "
+              "previously ignored a deletion: type %s name %s",
+              this, std::string(type->type_url()).c_str(),
+              std::string(name).c_str());
+    }
     authority_state.channel_state->UnsubscribeLocked(type, *resource_name,
                                                      delay_unsubscription);
     type_map.erase(resource_it);
@@ -1982,7 +2057,7 @@ absl::StatusOr<XdsClient::XdsResourceName> XdsClient::ParseXdsResourceName(
     absl::string_view name, const XdsResourceType* type) {
   // Old-style names use the empty string for authority.
   // authority is prefixed with "old:" to indicate that it's an old-style name.
-  if (!absl::StartsWith(name, "xdstp:")) {
+  if (!xds_federation_enabled_ || !absl::StartsWith(name, "xdstp:")) {
     return XdsResourceName{"old:", {std::string(name), {}}};
   }
   // New style name.  Parse URI.
@@ -2356,7 +2431,7 @@ std::string GetBootstrapContents(const char* fallback_config,
     grpc_slice contents;
     *error =
         grpc_load_file(path.get(), /*add_null_terminator=*/true, &contents);
-    if (*error != GRPC_ERROR_NONE) return "";
+    if (!GRPC_ERROR_IS_NONE(*error)) return "";
     std::string contents_str(StringViewFromSlice(contents));
     grpc_slice_unref_internal(contents);
     return contents_str;
@@ -2397,7 +2472,7 @@ RefCountedPtr<XdsClient> XdsClient::GetOrCreate(const grpc_channel_args* args,
   if (bootstrap_config != nullptr) {
     std::unique_ptr<XdsBootstrap> bootstrap =
         XdsBootstrap::Create(bootstrap_config, error);
-    if (*error == GRPC_ERROR_NONE) {
+    if (GRPC_ERROR_IS_NONE(*error)) {
       grpc_channel_args* xds_channel_args =
           grpc_channel_args_find_pointer<grpc_channel_args>(
               args,
@@ -2416,7 +2491,7 @@ RefCountedPtr<XdsClient> XdsClient::GetOrCreate(const grpc_channel_args* args,
     // Find bootstrap contents.
     std::string bootstrap_contents =
         GetBootstrapContents(g_fallback_bootstrap_config, error);
-    if (*error != GRPC_ERROR_NONE) return nullptr;
+    if (!GRPC_ERROR_IS_NONE(*error)) return nullptr;
     if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
       gpr_log(GPR_INFO, "xDS bootstrap contents: %s",
               bootstrap_contents.c_str());
@@ -2424,7 +2499,7 @@ RefCountedPtr<XdsClient> XdsClient::GetOrCreate(const grpc_channel_args* args,
     // Parse bootstrap.
     std::unique_ptr<XdsBootstrap> bootstrap =
         XdsBootstrap::Create(bootstrap_contents, error);
-    if (*error != GRPC_ERROR_NONE) return nullptr;
+    if (!GRPC_ERROR_IS_NONE(*error)) return nullptr;
     // Instantiate XdsClient.
     xds_client =
         MakeRefCounted<XdsClient>(std::move(bootstrap), g_channel_args);
@@ -2496,12 +2571,12 @@ RefCountedPtr<XdsClient> XdsClient::GetFromChannelArgs(
 }  // namespace grpc_core
 
 // The returned bytes may contain NULL(0), so we can't use c-string.
-grpc_slice grpc_dump_xds_configs() {
+grpc_slice grpc_dump_xds_configs(void) {
   grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
   grpc_core::ExecCtx exec_ctx;
   grpc_error_handle error = GRPC_ERROR_NONE;
   auto xds_client = grpc_core::XdsClient::GetOrCreate(nullptr, &error);
-  if (error != GRPC_ERROR_NONE) {
+  if (!GRPC_ERROR_IS_NONE(error)) {
     // If we isn't using xDS, just return an empty string.
     GRPC_ERROR_UNREF(error);
     return grpc_empty_slice();

data/src/core/ext/xds/xds_client.h

@@ -19,23 +19,36 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <map>
+#include <memory>
 #include <set>
+#include <string>
+#include <utility>
 #include <vector>
 
+#include "absl/base/thread_annotations.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
+#include "upb/def.hpp"
 
+#include <grpc/impl/codegen/grpc_types.h>
+
+#include "src/core/ext/xds/certificate_provider_store.h"
 #include "src/core/ext/xds/xds_api.h"
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/ext/xds/xds_client_stats.h"
 #include "src/core/ext/xds/xds_resource_type.h"
-#include "src/core/lib/channel/channelz.h"
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/dual_ref_counted.h"
-#include "src/core/lib/gprpp/memory.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/sync.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/work_serializer.h"
 #include "src/core/lib/uri/uri_parser.h"
 
@@ -234,6 +247,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
     // The latest data seen for the resource.
     std::unique_ptr<XdsResourceType::ResourceData> resource;
     XdsApi::ResourceMetadata meta;
+    bool ignored_deletion = false;
   };
 
   struct AuthorityState {
@@ -286,7 +300,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
   const XdsResourceType* GetResourceTypeLocked(absl::string_view resource_type)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
 
-  static absl::StatusOr<XdsResourceName> ParseXdsResourceName(
+  absl::StatusOr<XdsResourceName> ParseXdsResourceName(
       absl::string_view name, const XdsResourceType* type);
   static std::string ConstructFullXdsResourceName(
       absl::string_view authority, absl::string_view resource_type,
@@ -302,6 +316,7 @@ class XdsClient : public DualRefCounted<XdsClient> {
   std::unique_ptr<XdsBootstrap> bootstrap_;
   grpc_channel_args* args_;
   const Duration request_timeout_;
+  const bool xds_federation_enabled_;
   grpc_pollset_set* interested_parties_;
   OrphanablePtr<CertificateProviderStore> certificate_provider_store_;
   XdsApi api_;

data/src/core/ext/xds/xds_client_stats.cc

@@ -20,12 +20,11 @@
 
 #include "src/core/ext/xds/xds_client_stats.h"
 
-#include <string.h>
-
-#include <grpc/support/atm.h>
-#include <grpc/support/string_util.h>
+#include <grpc/support/log.h>
 
 #include "src/core/ext/xds/xds_client.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/debug_location.h"
 
 namespace grpc_core {
 

data/src/core/ext/xds/xds_client_stats.h

@@ -22,19 +22,20 @@
 #include <grpc/support/port_platform.h>
 
 #include <atomic>
+#include <cstdint>
 #include <map>
 #include <string>
+#include <utility>
 
-#include "absl/strings/str_cat.h"
+#include "absl/base/thread_annotations.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 
 namespace grpc_core {