grpc 1.70.1 → 1.71.0

data/src/core/util/work_serializer.cc

@@ -48,262 +48,35 @@ namespace grpc_core {
 // WorkSerializer::WorkSerializerImpl
 //
 
-class WorkSerializer::WorkSerializerImpl : public Orphanable {
- public:
-  virtual void Run(std::function<void()> callback,
-                   const DebugLocation& location) = 0;
-  virtual void Schedule(std::function<void()> callback,
-                        const DebugLocation& location) = 0;
-  virtual void DrainQueue() = 0;
-
-#ifndef NDEBUG
-  virtual bool RunningInWorkSerializer() const = 0;
-#endif
-};
-
-//
-// WorkSerializer::LegacyWorkSerializer
-//
-
-class WorkSerializer::LegacyWorkSerializer final : public WorkSerializerImpl {
- public:
-  void Run(std::function<void()> callback,
-           const DebugLocation& location) override;
-  void Schedule(std::function<void()> callback,
-                const DebugLocation& location) override;
-  void DrainQueue() override;
-  void Orphan() override;
-
-#ifndef NDEBUG
-  bool RunningInWorkSerializer() const override {
-    return std::this_thread::get_id() == current_thread_;
-  }
-#endif
-
- private:
-  struct CallbackWrapper {
-    CallbackWrapper(std::function<void()> cb, const DebugLocation& loc)
-        : callback(std::move(cb)), location(loc) {}
-
-    MultiProducerSingleConsumerQueue::Node mpscq_node;
-    const std::function<void()> callback;
-    const DebugLocation location;
-  };
-
-  // Callers of DrainQueueOwned should make sure to grab the lock on the
-  // workserializer with
-  //
-  //   prev_ref_pair =
-  //     refs_.fetch_add(MakeRefPair(1, 1), std::memory_order_acq_rel);
-  //
-  // and only invoke DrainQueueOwned() if there was previously no owner. Note
-  // that the queue size is also incremented as part of the fetch_add to allow
-  // the callers to add a callback to the queue if another thread already holds
-  // the lock to the work serializer.
-  void DrainQueueOwned();
-
-  // First 16 bits indicate ownership of the WorkSerializer, next 48 bits are
-  // queue size (i.e., refs).
-  static uint64_t MakeRefPair(uint16_t owners, uint64_t size) {
-    CHECK_EQ(size >> 48, 0u);
-    return (static_cast<uint64_t>(owners) << 48) + static_cast<int64_t>(size);
-  }
-  static uint32_t GetOwners(uint64_t ref_pair) {
-    return static_cast<uint32_t>(ref_pair >> 48);
-  }
-  static uint64_t GetSize(uint64_t ref_pair) {
-    return static_cast<uint64_t>(ref_pair & 0xffffffffffffu);
-  }
-
-#ifndef NDEBUG
-  void SetCurrentThread() { current_thread_ = std::this_thread::get_id(); }
-  void ClearCurrentThread() { current_thread_ = std::thread::id(); }
-#else
-  void SetCurrentThread() {}
-  void ClearCurrentThread() {}
-#endif
-
-  // An initial size of 1 keeps track of whether the work serializer has been
-  // orphaned.
-  std::atomic<uint64_t> refs_{MakeRefPair(0, 1)};
-  MultiProducerSingleConsumerQueue queue_;
-#ifndef NDEBUG
-  std::thread::id current_thread_;
-#endif
-};
-
-void WorkSerializer::LegacyWorkSerializer::Run(std::function<void()> callback,
-                                               const DebugLocation& location) {
-  GRPC_TRACE_LOG(work_serializer, INFO)
-      << "WorkSerializer::Run() " << this << " Scheduling callback ["
-      << location.file() << ":" << location.line() << "]";
-  // Increment queue size for the new callback and owner count to attempt to
-  // take ownership of the WorkSerializer.
-  const uint64_t prev_ref_pair =
-      refs_.fetch_add(MakeRefPair(1, 1), std::memory_order_acq_rel);
-  // The work serializer should not have been orphaned.
-  DCHECK_GT(GetSize(prev_ref_pair), 0u);
-  if (GetOwners(prev_ref_pair) == 0) {
-    // We took ownership of the WorkSerializer. Invoke callback and drain queue.
-    SetCurrentThread();
-    GRPC_TRACE_LOG(work_serializer, INFO) << "  Executing immediately";
-    callback();
-    // Delete the callback while still holding the WorkSerializer, so
-    // that any refs being held by the callback via lambda captures will
-    // be destroyed inside the WorkSerializer.
-    callback = nullptr;
-    DrainQueueOwned();
-  } else {
-    // Another thread is holding the WorkSerializer, so decrement the
-    // ownership count we just added and queue the callback.
-    refs_.fetch_sub(MakeRefPair(1, 0), std::memory_order_acq_rel);
-    CallbackWrapper* cb_wrapper =
-        new CallbackWrapper(std::move(callback), location);
-    GRPC_TRACE_LOG(work_serializer, INFO)
-        << "  Scheduling on queue : item " << cb_wrapper;
-    queue_.Push(&cb_wrapper->mpscq_node);
-  }
-}
-
-void WorkSerializer::LegacyWorkSerializer::Schedule(
-    std::function<void()> callback, const DebugLocation& location) {
-  CallbackWrapper* cb_wrapper =
-      new CallbackWrapper(std::move(callback), location);
-  GRPC_TRACE_LOG(work_serializer, INFO)
-      << "WorkSerializer::Schedule() " << this << " Scheduling callback "
-      << cb_wrapper << " [" << location.file() << ":" << location.line() << "]";
-  refs_.fetch_add(MakeRefPair(0, 1), std::memory_order_acq_rel);
-  queue_.Push(&cb_wrapper->mpscq_node);
-}
-
-void WorkSerializer::LegacyWorkSerializer::Orphan() {
-  GRPC_TRACE_LOG(work_serializer, INFO) << "WorkSerializer::Orphan() " << this;
-  const uint64_t prev_ref_pair =
-      refs_.fetch_sub(MakeRefPair(0, 1), std::memory_order_acq_rel);
-  if (GetOwners(prev_ref_pair) == 0 && GetSize(prev_ref_pair) == 1) {
-    GRPC_TRACE_LOG(work_serializer, INFO) << "  Destroying";
-    delete this;
-  }
-}
-
-// The thread that calls this loans itself to the work serializer so as to
-// execute all the scheduled callbacks.
-void WorkSerializer::LegacyWorkSerializer::DrainQueue() {
-  GRPC_TRACE_LOG(work_serializer, INFO)
-      << "WorkSerializer::DrainQueue() " << this;
-  // Attempt to take ownership of the WorkSerializer. Also increment the queue
-  // size as required by `DrainQueueOwned()`.
-  const uint64_t prev_ref_pair =
-      refs_.fetch_add(MakeRefPair(1, 1), std::memory_order_acq_rel);
-  if (GetOwners(prev_ref_pair) == 0) {
-    SetCurrentThread();
-    // We took ownership of the WorkSerializer. Drain the queue.
-    DrainQueueOwned();
-  } else {
-    // Another thread is holding the WorkSerializer, so decrement the
-    // ownership count we just added and queue a no-op callback.
-    refs_.fetch_sub(MakeRefPair(1, 0), std::memory_order_acq_rel);
-    CallbackWrapper* cb_wrapper = new CallbackWrapper([]() {}, DEBUG_LOCATION);
-    queue_.Push(&cb_wrapper->mpscq_node);
-  }
-}
-
-void WorkSerializer::LegacyWorkSerializer::DrainQueueOwned() {
-  GRPC_TRACE_LOG(work_serializer, INFO)
-      << "WorkSerializer::DrainQueueOwned() " << this;
-  while (true) {
-    auto prev_ref_pair = refs_.fetch_sub(MakeRefPair(0, 1));
-    // It is possible that while draining the queue, the last callback ended
-    // up orphaning the work serializer. In that case, delete the object.
-    if (GetSize(prev_ref_pair) == 1) {
-      GRPC_TRACE_LOG(work_serializer, INFO) << "  Queue Drained. Destroying";
-      delete this;
-      return;
-    }
-    if (GetSize(prev_ref_pair) == 2) {
-      // Queue drained. Give up ownership but only if queue remains empty.
-      // Reset current_thread_ before giving up ownership to avoid TSAN
-      // race.  If we don't wind up giving up ownership, we'll set this
-      // again below before we pull the next callback out of the queue.
-      ClearCurrentThread();
-      uint64_t expected = MakeRefPair(1, 1);
-      if (refs_.compare_exchange_strong(expected, MakeRefPair(0, 1),
-                                        std::memory_order_acq_rel)) {
-        // Queue is drained.
-        return;
-      }
-      if (GetSize(expected) == 0) {
-        // WorkSerializer got orphaned while this was running
-        GRPC_TRACE_LOG(work_serializer, INFO) << "  Queue Drained. Destroying";
-        delete this;
-        return;
-      }
-      // Didn't wind up giving up ownership, so set current_thread_ again.
-      SetCurrentThread();
-    }
-    // There is at least one callback on the queue. Pop the callback from the
-    // queue and execute it.
-    CallbackWrapper* cb_wrapper = nullptr;
-    bool empty_unused;
-    while ((cb_wrapper = reinterpret_cast<CallbackWrapper*>(
-                queue_.PopAndCheckEnd(&empty_unused))) == nullptr) {
-      // This can happen due to a race condition within the mpscq
-      // implementation or because of a race with Run()/Schedule().
-      GRPC_TRACE_LOG(work_serializer, INFO)
-          << "  Queue returned nullptr, trying again";
-    }
-    GRPC_TRACE_LOG(work_serializer, INFO)
-        << "  Running item " << cb_wrapper << " : callback scheduled at ["
-        << cb_wrapper->location.file() << ":" << cb_wrapper->location.line()
-        << "]";
-    cb_wrapper->callback();
-    delete cb_wrapper;
-  }
-}
-
-//
-// WorkSerializer::DispatchingWorkSerializer
-//
-
-// DispatchingWorkSerializer: executes callbacks one at a time on EventEngine.
+// Executes callbacks one at a time on EventEngine.
 // One at a time guarantees that fixed size thread pools in EventEngine
 // implementations are not starved of threads by long running work
 // serializers. We implement EventEngine::Closure directly to avoid allocating
 // once per callback in the queue when scheduling.
-class WorkSerializer::DispatchingWorkSerializer final
-    : public WorkSerializerImpl,
+class WorkSerializer::WorkSerializerImpl
+    : public Orphanable,
       public grpc_event_engine::experimental::EventEngine::Closure {
  public:
-  explicit DispatchingWorkSerializer(
+  explicit WorkSerializerImpl(
       std::shared_ptr<grpc_event_engine::experimental::EventEngine>
           event_engine)
       : event_engine_(std::move(event_engine)) {}
-  void Run(std::function<void()> callback,
-           const DebugLocation& location) override;
-  void Schedule(std::function<void()> callback,
-                const DebugLocation& location) override {
-    // We always dispatch to event engine, so Schedule and Run share
-    // semantics.
-    Run(callback, location);
-  }
-  void DrainQueue() override {}
-  void Orphan() override;
-
-  // Override EventEngine::Closure
+  void Run(absl::AnyInvocable<void()> callback, DebugLocation location);
   void Run() override;
+  void Orphan() override;
 
 #ifndef NDEBUG
-  bool RunningInWorkSerializer() const override {
+  bool RunningInWorkSerializer() const {
     return running_work_serializer_ == this;
   }
 #endif
-
  private:
   // Wrapper to capture DebugLocation for the callback.
   struct CallbackWrapper {
-    CallbackWrapper(std::function<void()> cb, const DebugLocation& loc)
-        : callback(std::move(cb)), location(loc) {}
-    std::function<void()> callback;
+    CallbackWrapper(absl::AnyInvocable<void()>&& cb, const DebugLocation& loc)
+        : callback(std::forward<absl::AnyInvocable<void()>>(cb)),
+          location(loc) {}
+    absl::AnyInvocable<void()> callback;
     // GPR_NO_UNIQUE_ADDRESS means this is 0 sized in release builds.
     GPR_NO_UNIQUE_ADDRESS DebugLocation location;
   };
@@ -351,8 +124,8 @@ class WorkSerializer::DispatchingWorkSerializer final
   //   on an idle WorkSerializer, and transitions back to false after the last
   //   callback scheduled is completed and the WorkSerializer is again idle.
   // - orphaned_ transitions to true once upon Orphan being called.
-  // When orphaned_ is true and running_ is false, the
-  // DispatchingWorkSerializer instance is deleted.
+  // When orphaned_ is true and running_ is false, the WorkSerializerImpl
+  // instance is deleted.
   bool running_ ABSL_GUARDED_BY(mu_) = false;
   bool orphaned_ ABSL_GUARDED_BY(mu_) = false;
   Mutex mu_;
@@ -366,17 +139,16 @@ class WorkSerializer::DispatchingWorkSerializer final
   GPR_NO_UNIQUE_ADDRESS latent_see::Flow flow_;
 
 #ifndef NDEBUG
-  static thread_local DispatchingWorkSerializer* running_work_serializer_;
+  static thread_local WorkSerializerImpl* running_work_serializer_;
 #endif
 };
 
 #ifndef NDEBUG
-thread_local WorkSerializer::DispatchingWorkSerializer*
-    WorkSerializer::DispatchingWorkSerializer::running_work_serializer_ =
-        nullptr;
+thread_local WorkSerializer::WorkSerializerImpl*
+    WorkSerializer::WorkSerializerImpl::running_work_serializer_ = nullptr;
 #endif
 
-void WorkSerializer::DispatchingWorkSerializer::Orphan() {
+void WorkSerializer::WorkSerializerImpl::Orphan() {
   ReleasableMutexLock lock(&mu_);
   // If we're not running, then we can delete immediately.
   if (!running_) {
@@ -389,8 +161,8 @@ void WorkSerializer::DispatchingWorkSerializer::Orphan() {
 }
 
 // Implementation of WorkSerializerImpl::Run
-void WorkSerializer::DispatchingWorkSerializer::Run(
-    std::function<void()> callback, const DebugLocation& location) {
+void WorkSerializer::WorkSerializerImpl::Run(
+    absl::AnyInvocable<void()> callback, DebugLocation location) {
   GRPC_TRACE_LOG(work_serializer, INFO)
       << "WorkSerializer[" << this << "] Scheduling callback ["
       << location.file() << ":" << location.line() << "]";
@@ -414,11 +186,10 @@ void WorkSerializer::DispatchingWorkSerializer::Run(
 }
 
 // Implementation of EventEngine::Closure::Run - our actual work loop
-void WorkSerializer::DispatchingWorkSerializer::Run() {
+void WorkSerializer::WorkSerializerImpl::Run() {
   GRPC_LATENT_SEE_PARENT_SCOPE("WorkSerializer::Run");
   flow_.End();
   // TODO(ctiller): remove these when we can deprecate ExecCtx
-  ApplicationCallbackExecCtx app_exec_ctx;
   ExecCtx exec_ctx;
   // Grab the last element of processing_ - which is the next item in our
   // queue since processing_ is stored in reverse order.
@@ -449,8 +220,8 @@ void WorkSerializer::DispatchingWorkSerializer::Run() {
   event_engine_->Run(this);
 }
 
-WorkSerializer::DispatchingWorkSerializer::RefillResult
-WorkSerializer::DispatchingWorkSerializer::RefillInner() {
+WorkSerializer::WorkSerializerImpl::RefillResult
+WorkSerializer::WorkSerializerImpl::RefillInner() {
   // Recover any memory held by processing_, so that we don't grow forever.
   // Do so before acquiring a lock so we don't cause inadvertent contention.
   processing_.shrink_to_fit();
@@ -481,7 +252,7 @@ WorkSerializer::DispatchingWorkSerializer::RefillInner() {
   return RefillResult::kRefilled;
 }
 
-bool WorkSerializer::DispatchingWorkSerializer::Refill() {
+bool WorkSerializer::WorkSerializerImpl::Refill() {
   const auto result = RefillInner();
   switch (result) {
     case RefillResult::kRefilled:
@@ -508,27 +279,16 @@ bool WorkSerializer::DispatchingWorkSerializer::Refill() {
 
 WorkSerializer::WorkSerializer(
     std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine)
-    : impl_(IsWorkSerializerDispatchEnabled()
-                ? OrphanablePtr<WorkSerializerImpl>(
-                      MakeOrphanable<DispatchingWorkSerializer>(
-                          std::move(event_engine)))
-                : OrphanablePtr<WorkSerializerImpl>(
-                      MakeOrphanable<LegacyWorkSerializer>())) {}
+    : impl_(OrphanablePtr<WorkSerializerImpl>(
+          MakeOrphanable<WorkSerializerImpl>(std::move(event_engine)))) {}
 
 WorkSerializer::~WorkSerializer() = default;
 
-void WorkSerializer::Run(std::function<void()> callback,
-                         const DebugLocation& location) {
+void WorkSerializer::Run(absl::AnyInvocable<void()> callback,
+                         DebugLocation location) {
   impl_->Run(std::move(callback), location);
 }
 
-void WorkSerializer::Schedule(std::function<void()> callback,
-                              const DebugLocation& location) {
-  impl_->Schedule(std::move(callback), location);
-}
-
-void WorkSerializer::DrainQueue() { impl_->DrainQueue(); }
-
 #ifndef NDEBUG
 bool WorkSerializer::RunningInWorkSerializer() const {
   return impl_->RunningInWorkSerializer();

data/src/core/util/work_serializer.h

@@ -24,6 +24,7 @@
 #include <memory>
 
 #include "absl/base/thread_annotations.h"
+#include "absl/functional/any_invocable.h"
 #include "src/core/util/debug_location.h"
 #include "src/core/util/orphanable.h"
 
@@ -33,16 +34,7 @@ namespace grpc_core {
 // All callbacks scheduled on a WorkSerializer instance will be executed
 // serially in a borrowed thread. The API provides a FIFO guarantee to the
 // execution of callbacks scheduled on the thread.
-// When a thread calls Run() with a callback, the thread is considered borrowed.
-// The callback might run inline, or it might run asynchronously in a different
-// thread that is already inside of Run(). If the callback runs directly inline,
-// other callbacks from other threads might also be executed before Run()
-// returns. Since an arbitrary set of callbacks might be executed when Run() is
-// called, generally no locks should be held while calling Run().
-// If a thread wants to preclude the possibility of the callback being invoked
-// inline in Run() (for example, if a mutex lock is held and executing callbacks
-// inline would cause a deadlock), it should use Schedule() instead and then
-// invoke DrainQueue() when it is safe to invoke the callback.
+// When a thread calls Run() with a callback the callback runs asynchronously.
 class ABSL_LOCKABLE WorkSerializer {
  public:
   explicit WorkSerializer(
@@ -57,17 +49,9 @@ class ABSL_LOCKABLE WorkSerializer {
 
   // Runs a given callback on the work serializer.
   //
-  // If experiment `work_serializer_dispatch` is enabled:
   // The callback will be executed as an EventEngine callback, that then
   // arranges for the next callback in the queue to execute.
   //
-  // If experiment `work_serializer_dispatch` is NOT enabled:
-  // If there is no other thread currently executing the WorkSerializer, the
-  // callback is run immediately. In this case, the current thread is also
-  // borrowed for draining the queue for any callbacks that get added in the
-  // meantime.
-  // This behavior is deprecated and will be removed soon.
-  //
   // If you want to use clang thread annotation to make sure that callback is
   // called by WorkSerializer only, you need to add the annotation to both the
   // lambda function given to Run and the actual callback function like;
@@ -79,13 +63,7 @@ class ABSL_LOCKABLE WorkSerializer {
   //         }, DEBUG_LOCATION);
   //   }
   //   void callback() ABSL_EXCLUSIVE_LOCKS_REQUIRED(work_serializer) { ... }
-  void Run(std::function<void()> callback, const DebugLocation& location);
-
-  // Schedule \a callback to be run later when the queue of callbacks is
-  // drained.
-  void Schedule(std::function<void()> callback, const DebugLocation& location);
-  // Drains the queue of callbacks.
-  void DrainQueue();
+  void Run(absl::AnyInvocable<void()> callback, DebugLocation location = {});
 
 #ifndef NDEBUG
   // Returns true if the current thread is running in the WorkSerializer.
@@ -94,8 +72,6 @@ class ABSL_LOCKABLE WorkSerializer {
 
  private:
   class WorkSerializerImpl;
-  class LegacyWorkSerializer;
-  class DispatchingWorkSerializer;
 
   OrphanablePtr<WorkSerializerImpl> impl_;
 };

data/src/core/xds/grpc/certificate_provider_store.cc

@@ -103,13 +103,11 @@ CertificateProviderStore::CreateOrGetCertificateProvider(
     if (result != nullptr) {
       certificate_providers_map_.insert({result->key(), result.get()});
     }
-  } else {
-    result =
-        it->second->RefIfNonZero().TakeAsSubclass<CertificateProviderWrapper>();
-    if (result == nullptr) {
-      result = CreateCertificateProviderLocked(key);
-      it->second = result.get();
-    }
+  } else if (result = it->second->RefIfNonZero()
+                          .TakeAsSubclass<CertificateProviderWrapper>();
+             result == nullptr) {
+    result = CreateCertificateProviderLocked(key);
+    it->second = result.get();
   }
   return result;
 }
@@ -117,26 +115,23 @@ CertificateProviderStore::CreateOrGetCertificateProvider(
 RefCountedPtr<CertificateProviderStore::CertificateProviderWrapper>
 CertificateProviderStore::CreateCertificateProviderLocked(
     absl::string_view key) {
-  auto plugin_config_it = plugin_config_map_.find(std::string(key));
-  if (plugin_config_it == plugin_config_map_.end()) {
-    return nullptr;
-  }
+  auto it = plugin_config_map_.find(std::string(key));
+  if (it == plugin_config_map_.end()) return nullptr;
+  const auto& [name, definition] = *it;
   CertificateProviderFactory* factory =
       CoreConfiguration::Get()
           .certificate_provider_registry()
-          .LookupCertificateProviderFactory(
-              plugin_config_it->second.plugin_name);
+          .LookupCertificateProviderFactory(definition.plugin_name);
   if (factory == nullptr) {
     // This should never happen since an entry is only inserted in the
     // plugin_config_map_ if the corresponding factory was found when parsing
     // the xDS bootstrap file.
-    LOG(ERROR) << "Certificate provider factory "
-               << plugin_config_it->second.plugin_name << " not found";
+    LOG(ERROR) << "Certificate provider factory " << definition.plugin_name
+               << " not found";
     return nullptr;
   }
   return MakeRefCounted<CertificateProviderWrapper>(
-      factory->CreateCertificateProvider(plugin_config_it->second.config),
-      Ref(), plugin_config_it->first);
+      factory->CreateCertificateProvider(definition.config), Ref(), name);
 }
 
 void CertificateProviderStore::ReleaseCertificateProvider(

data/src/core/xds/grpc/file_watcher_certificate_provider_factory.cc

@@ -18,7 +18,6 @@
 
 #include "src/core/xds/grpc/file_watcher_certificate_provider_factory.h"
 
-#include <grpc/support/port_platform.h>
 #include <grpc/support/time.h>
 
 #include <algorithm>
@@ -31,6 +30,7 @@
 #include "absl/strings/str_join.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/security/credentials/tls/grpc_tls_certificate_provider.h"
+#include "src/core/util/down_cast.h"
 
 namespace grpc_core {
 
@@ -119,7 +119,7 @@ FileWatcherCertificateProviderFactory::CreateCertificateProvider(
     return nullptr;
   }
   auto* file_watcher_config =
-      static_cast<FileWatcherCertificateProviderFactory::Config*>(config.get());
+      DownCast<FileWatcherCertificateProviderFactory::Config*>(config.get());
   return MakeRefCounted<FileWatcherCertificateProvider>(
       file_watcher_config->private_key_file(),
       file_watcher_config->identity_cert_file(),

data/src/core/xds/grpc/xds_audit_logger_registry.cc

@@ -18,13 +18,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <string>
 #include <utility>
 
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "envoy/config/core/v3/extension.upb.h"
 #include "envoy/config/rbac/v3/rbac.upb.h"
 #include "src/core/lib/security/authorization/audit_logging.h"

data/src/core/xds/grpc/xds_bootstrap_grpc.cc

@@ -17,9 +17,9 @@
 #include "src/core/xds/grpc/xds_bootstrap_grpc.h"
 
 #include <grpc/support/json.h>
-#include <grpc/support/port_platform.h>
 #include <stdlib.h>
 
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -31,7 +31,7 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
+#include "src/core/util/down_cast.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_object_loader.h"
 #include "src/core/util/json/json_reader.h"
@@ -146,10 +146,7 @@ void GrpcXdsBootstrap::JsonPostLoad(const Json& /*json*/,
   // client_listener_resource_name_template field.
   {
     ValidationErrors::ScopedField field(errors, ".authorities");
-    for (const auto& p : authorities_) {
-      const std::string& name = p.first;
-      const GrpcAuthority& authority =
-          static_cast<const GrpcAuthority&>(p.second);
+    for (const auto& [name, authority] : authorities_) {
       ValidationErrors::ScopedField field(
           errors, absl::StrCat("[\"", name,
                                "\"].client_listener_resource_name_template"));
@@ -195,15 +192,15 @@ std::string GrpcXdsBootstrap::ToString() const {
                         server_listener_resource_name_template_));
   }
   parts.push_back("authorities={\n");
-  for (const auto& entry : authorities_) {
-    parts.push_back(absl::StrFormat("  %s={\n", entry.first));
+  for (const auto& [name, authority] : authorities_) {
+    parts.push_back(absl::StrFormat("  %s={\n", name));
     parts.push_back(
         absl::StrFormat("    client_listener_resource_name_template=\"%s\",\n",
-                        entry.second.client_listener_resource_name_template()));
+                        authority.client_listener_resource_name_template()));
     std::vector<std::string> server_jsons;
-    for (const XdsServer* server : entry.second.servers()) {
+    for (const XdsServer* server : authority.servers()) {
       server_jsons.emplace_back(
-          JsonDump(static_cast<const GrpcXdsServer*>(server)->ToJson()));
+          JsonDump(DownCast<const GrpcXdsServer*>(server)->ToJson()));
     }
     if (!server_jsons.empty()) {
       parts.push_back(absl::StrFormat("    servers=[\n%s\n],\n",
@@ -213,14 +210,14 @@ std::string GrpcXdsBootstrap::ToString() const {
   }
   parts.push_back("}\n");
   parts.push_back("certificate_providers={\n");
-  for (const auto& entry : certificate_providers_) {
+  for (const auto& [name, plugin_definition] : certificate_providers_) {
     parts.push_back(
         absl::StrFormat("  %s={\n"
                         "    plugin_name=%s\n"
                         "    config=%s\n"
                         "  },\n",
-                        entry.first, entry.second.plugin_name,
-                        entry.second.config->ToString()));
+                        name, plugin_definition.plugin_name,
+                        plugin_definition.config->ToString()));
   }
   parts.push_back("}");
   return absl::StrJoin(parts, "");

data/src/core/xds/grpc/xds_bootstrap_grpc.h

@@ -21,12 +21,12 @@
 
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include <vector>
 
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_args.h"
 #include "src/core/util/json/json_object_loader.h"
@@ -151,7 +151,7 @@ class GrpcXdsBootstrap final : public XdsBootstrap {
 
  private:
   std::vector<GrpcXdsServer> servers_;
-  absl::optional<GrpcNode> node_;
+  std::optional<GrpcNode> node_;
   std::string client_default_listener_resource_name_template_;
   std::string server_listener_resource_name_template_;
   std::map<std::string, GrpcAuthority> authorities_;