grpc 1.40.0.pre1 → 1.42.0.pre1

data/src/core/lib/{transport/authority_override.cc → gprpp/construct_destruct.h}

@@ -1,5 +1,4 @@
-//
-// Copyright 2020 gRPC authors.
+// Copyright 2021 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,29 +11,29 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-//
-
-#include <grpc/support/port_platform.h>
 
-#include "absl/strings/string_view.h"
+#ifndef GRPC_CORE_LIB_GPRPP_CONSTRUCT_DESTRUCT_H
+#define GRPC_CORE_LIB_GPRPP_CONSTRUCT_DESTRUCT_H
 
-#include "src/core/lib/channel/channel_args.h"
+#include <grpc/support/port_platform.h>
 
-// Channel arg key for the authority override.
-#define GRPC_ARG_AUTHORITY_OVERRIDE "grpc.authority_override"
+#include <utility>
 
 namespace grpc_core {
 
-grpc_arg CreateAuthorityOverrideChannelArg(const char* authority) {
-  return grpc_channel_arg_string_create(
-      const_cast<char*>(GRPC_ARG_AUTHORITY_OVERRIDE),
-      const_cast<char*>(authority));
+// Call the destructor of p without having to name the type of p.
+template <typename T>
+void Destruct(T* p) {
+  p->~T();
 }
 
-absl::string_view FindAuthorityOverrideInArgs(const grpc_channel_args* args) {
-  const char* found =
-      grpc_channel_args_find_string(args, GRPC_ARG_AUTHORITY_OVERRIDE);
-  return found == nullptr ? "" : found;
+// Call the constructor of p without having to name the type of p and forward
+// any arguments
+template <typename T, typename... Args>
+void Construct(T* p, Args&&... args) {
+  new (p) T(std::forward<Args>(args)...);
 }
 
 }  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_CONSTRUCT_DESTRUCT_H

data/src/core/lib/gprpp/dual_ref_counted.h

@@ -19,15 +19,14 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/atm.h>
-#include <grpc/support/log.h>
-#include <grpc/support/sync.h>
-
 #include <atomic>
 #include <cassert>
 #include <cinttypes>
 
-#include "src/core/lib/gprpp/atomic.h"
+#include <grpc/support/atm.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -67,7 +66,7 @@ class DualRefCounted : public Orphanable {
   void Unref() {
     // Convert strong ref to weak ref.
     const uint64_t prev_ref_pair =
-        refs_.FetchAdd(MakeRefPair(-1, 1), MemoryOrder::ACQ_REL);
+        refs_.fetch_add(MakeRefPair(-1, 1), std::memory_order_acq_rel);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
 #ifndef NDEBUG
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
@@ -85,7 +84,7 @@ class DualRefCounted : public Orphanable {
   }
   void Unref(const DebugLocation& location, const char* reason) {
     const uint64_t prev_ref_pair =
-        refs_.FetchAdd(MakeRefPair(-1, 1), MemoryOrder::ACQ_REL);
+        refs_.fetch_add(MakeRefPair(-1, 1), std::memory_order_acq_rel);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
 #ifndef NDEBUG
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
@@ -108,7 +107,7 @@ class DualRefCounted : public Orphanable {
   }
 
   RefCountedPtr<Child> RefIfNonZero() GRPC_MUST_USE_RESULT {
-    uint64_t prev_ref_pair = refs_.Load(MemoryOrder::ACQUIRE);
+    uint64_t prev_ref_pair = refs_.load(std::memory_order_acquire);
     do {
       const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
 #ifndef NDEBUG
@@ -119,15 +118,15 @@ class DualRefCounted : public Orphanable {
       }
 #endif
       if (strong_refs == 0) return nullptr;
-    } while (!refs_.CompareExchangeWeak(
-        &prev_ref_pair, prev_ref_pair + MakeRefPair(1, 0), MemoryOrder::ACQ_REL,
-        MemoryOrder::ACQUIRE));
+    } while (!refs_.compare_exchange_weak(
+        prev_ref_pair, prev_ref_pair + MakeRefPair(1, 0),
+        std::memory_order_acq_rel, std::memory_order_acquire));
     return RefCountedPtr<Child>(static_cast<Child*>(this));
   }
 
   RefCountedPtr<Child> RefIfNonZero(const DebugLocation& location,
                                     const char* reason) GRPC_MUST_USE_RESULT {
-    uint64_t prev_ref_pair = refs_.Load(MemoryOrder::ACQUIRE);
+    uint64_t prev_ref_pair = refs_.load(std::memory_order_acquire);
     do {
       const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
 #ifndef NDEBUG
@@ -144,9 +143,9 @@ class DualRefCounted : public Orphanable {
       (void)reason;
 #endif
       if (strong_refs == 0) return nullptr;
-    } while (!refs_.CompareExchangeWeak(
-        &prev_ref_pair, prev_ref_pair + MakeRefPair(1, 0), MemoryOrder::ACQ_REL,
-        MemoryOrder::ACQUIRE));
+    } while (!refs_.compare_exchange_weak(
+        prev_ref_pair, prev_ref_pair + MakeRefPair(1, 0),
+        std::memory_order_acq_rel, std::memory_order_acquire));
     return RefCountedPtr<Child>(static_cast<Child*>(this));
   }
 
@@ -169,7 +168,7 @@ class DualRefCounted : public Orphanable {
     const char* trace = trace_;
 #endif
     const uint64_t prev_ref_pair =
-        refs_.FetchSub(MakeRefPair(0, 1), MemoryOrder::ACQ_REL);
+        refs_.fetch_sub(MakeRefPair(0, 1), std::memory_order_acq_rel);
 #ifndef NDEBUG
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
@@ -191,7 +190,7 @@ class DualRefCounted : public Orphanable {
     const char* trace = trace_;
 #endif
     const uint64_t prev_ref_pair =
-        refs_.FetchSub(MakeRefPair(0, 1), MemoryOrder::ACQ_REL);
+        refs_.fetch_sub(MakeRefPair(0, 1), std::memory_order_acq_rel);
 #ifndef NDEBUG
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
@@ -254,7 +253,7 @@ class DualRefCounted : public Orphanable {
   void IncrementRefCount() {
 #ifndef NDEBUG
     const uint64_t prev_ref_pair =
-        refs_.FetchAdd(MakeRefPair(1, 0), MemoryOrder::RELAXED);
+        refs_.fetch_add(MakeRefPair(1, 0), std::memory_order_relaxed);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     GPR_ASSERT(strong_refs != 0);
@@ -263,13 +262,13 @@ class DualRefCounted : public Orphanable {
               strong_refs, strong_refs + 1, weak_refs);
     }
 #else
-    refs_.FetchAdd(MakeRefPair(1, 0), MemoryOrder::RELAXED);
+    refs_.fetch_add(MakeRefPair(1, 0), std::memory_order_relaxed);
 #endif
   }
   void IncrementRefCount(const DebugLocation& location, const char* reason) {
 #ifndef NDEBUG
     const uint64_t prev_ref_pair =
-        refs_.FetchAdd(MakeRefPair(1, 0), MemoryOrder::RELAXED);
+        refs_.fetch_add(MakeRefPair(1, 0), std::memory_order_relaxed);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     GPR_ASSERT(strong_refs != 0);
@@ -282,14 +281,14 @@ class DualRefCounted : public Orphanable {
     // Use conditionally-important parameters
     (void)location;
     (void)reason;
-    refs_.FetchAdd(MakeRefPair(1, 0), MemoryOrder::RELAXED);
+    refs_.fetch_add(MakeRefPair(1, 0), std::memory_order_relaxed);
 #endif
   }
 
   void IncrementWeakRefCount() {
 #ifndef NDEBUG
     const uint64_t prev_ref_pair =
-        refs_.FetchAdd(MakeRefPair(0, 1), MemoryOrder::RELAXED);
+        refs_.fetch_add(MakeRefPair(0, 1), std::memory_order_relaxed);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     if (trace_ != nullptr) {
@@ -297,14 +296,14 @@ class DualRefCounted : public Orphanable {
               weak_refs, weak_refs + 1, strong_refs);
     }
 #else
-    refs_.FetchAdd(MakeRefPair(0, 1), MemoryOrder::RELAXED);
+    refs_.fetch_add(MakeRefPair(0, 1), std::memory_order_relaxed);
 #endif
   }
   void IncrementWeakRefCount(const DebugLocation& location,
                              const char* reason) {
 #ifndef NDEBUG
     const uint64_t prev_ref_pair =
-        refs_.FetchAdd(MakeRefPair(0, 1), MemoryOrder::RELAXED);
+        refs_.fetch_add(MakeRefPair(0, 1), std::memory_order_relaxed);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     if (trace_ != nullptr) {
@@ -316,14 +315,14 @@ class DualRefCounted : public Orphanable {
     // Use conditionally-important parameters
     (void)location;
     (void)reason;
-    refs_.FetchAdd(MakeRefPair(0, 1), MemoryOrder::RELAXED);
+    refs_.fetch_add(MakeRefPair(0, 1), std::memory_order_relaxed);
 #endif
   }
 
 #ifndef NDEBUG
   const char* trace_;
 #endif
-  Atomic<uint64_t> refs_;
+  std::atomic<uint64_t> refs_{0};
 };
 
 }  // namespace grpc_core

data/src/core/lib/gprpp/fork.cc

@@ -168,28 +168,30 @@ class ThreadState {
 
 void Fork::GlobalInit() {
   if (!override_enabled_) {
-    support_enabled_.Store(GPR_GLOBAL_CONFIG_GET(grpc_enable_fork_support),
-                           MemoryOrder::RELAXED);
+    support_enabled_.store(GPR_GLOBAL_CONFIG_GET(grpc_enable_fork_support),
+                           std::memory_order_relaxed);
   }
-  if (support_enabled_.Load(MemoryOrder::RELAXED)) {
+  if (support_enabled_.load(std::memory_order_relaxed)) {
     exec_ctx_state_ = new internal::ExecCtxState();
     thread_state_ = new internal::ThreadState();
   }
 }
 
 void Fork::GlobalShutdown() {
-  if (support_enabled_.Load(MemoryOrder::RELAXED)) {
+  if (support_enabled_.load(std::memory_order_relaxed)) {
     delete exec_ctx_state_;
     delete thread_state_;
   }
 }
 
-bool Fork::Enabled() { return support_enabled_.Load(MemoryOrder::RELAXED); }
+bool Fork::Enabled() {
+  return support_enabled_.load(std::memory_order_relaxed);
+}
 
 // Testing Only
 void Fork::Enable(bool enable) {
   override_enabled_ = true;
-  support_enabled_.Store(enable, MemoryOrder::RELAXED);
+  support_enabled_.store(enable, std::memory_order_relaxed);
 }
 
 void Fork::DoIncExecCtxCount() { exec_ctx_state_->IncExecCtxCount(); }
@@ -205,38 +207,38 @@ Fork::child_postfork_func Fork::GetResetChildPollingEngineFunc() {
 }
 
 bool Fork::BlockExecCtx() {
-  if (support_enabled_.Load(MemoryOrder::RELAXED)) {
+  if (support_enabled_.load(std::memory_order_relaxed)) {
     return exec_ctx_state_->BlockExecCtx();
   }
   return false;
 }
 
 void Fork::AllowExecCtx() {
-  if (support_enabled_.Load(MemoryOrder::RELAXED)) {
+  if (support_enabled_.load(std::memory_order_relaxed)) {
     exec_ctx_state_->AllowExecCtx();
   }
 }
 
 void Fork::IncThreadCount() {
-  if (support_enabled_.Load(MemoryOrder::RELAXED)) {
+  if (support_enabled_.load(std::memory_order_relaxed)) {
     thread_state_->IncThreadCount();
   }
 }
 
 void Fork::DecThreadCount() {
-  if (support_enabled_.Load(MemoryOrder::RELAXED)) {
+  if (support_enabled_.load(std::memory_order_relaxed)) {
     thread_state_->DecThreadCount();
   }
 }
 void Fork::AwaitThreads() {
-  if (support_enabled_.Load(MemoryOrder::RELAXED)) {
+  if (support_enabled_.load(std::memory_order_relaxed)) {
     thread_state_->AwaitThreads();
   }
 }
 
 internal::ExecCtxState* Fork::exec_ctx_state_ = nullptr;
 internal::ThreadState* Fork::thread_state_ = nullptr;
-Atomic<bool> Fork::support_enabled_(false);
+std::atomic<bool> Fork::support_enabled_(false);
 bool Fork::override_enabled_ = false;
 Fork::child_postfork_func Fork::reset_child_polling_engine_ = nullptr;
 }  // namespace grpc_core

data/src/core/lib/gprpp/fork.h

@@ -21,7 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gprpp/atomic.h"
+#include <atomic>
 
 /*
  * NOTE: FORKING IS NOT GENERALLY SUPPORTED, THIS IS ONLY INTENDED TO WORK
@@ -48,14 +48,14 @@ class Fork {
   // Increment the count of active ExecCtxs.
   // Will block until a pending fork is complete if one is in progress.
   static void IncExecCtxCount() {
-    if (GPR_UNLIKELY(support_enabled_.Load(MemoryOrder::RELAXED))) {
+    if (GPR_UNLIKELY(support_enabled_.load(std::memory_order_relaxed))) {
       DoIncExecCtxCount();
     }
   }
 
   // Decrement the count of active ExecCtxs
   static void DecExecCtxCount() {
-    if (GPR_UNLIKELY(support_enabled_.Load(MemoryOrder::RELAXED))) {
+    if (GPR_UNLIKELY(support_enabled_.load(std::memory_order_relaxed))) {
       DoDecExecCtxCount();
     }
   }
@@ -93,7 +93,7 @@ class Fork {
 
   static internal::ExecCtxState* exec_ctx_state_;
   static internal::ThreadState* thread_state_;
-  static grpc_core::Atomic<bool> support_enabled_;
+  static std::atomic<bool> support_enabled_;
   static bool override_enabled_;
   static child_postfork_func reset_child_polling_engine_;
 };

data/src/core/lib/gprpp/global_config.h

@@ -89,8 +89,7 @@
 //   bool gpr_global_config_get_test();
 //   void gpr_global_config_set_test(bool value);
 
-#include "src/core/lib/gprpp/global_config_env.h"
-
 #include "src/core/lib/gprpp/global_config_custom.h"
+#include "src/core/lib/gprpp/global_config_env.h"
 
 #endif /* GRPC_CORE_LIB_GPRPP_GLOBAL_CONFIG_H */

data/src/core/lib/gprpp/global_config_env.cc

@@ -20,13 +20,6 @@
 
 #include "src/core/lib/gprpp/global_config_env.h"
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
-
-#include "src/core/lib/gpr/env.h"
-#include "src/core/lib/gpr/string.h"
-
 #include <ctype.h>
 #include <string.h>
 
@@ -34,6 +27,13 @@
 
 #include "absl/strings/str_format.h"
 
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+
+#include "src/core/lib/gpr/env.h"
+#include "src/core/lib/gpr/string.h"
+
 namespace grpc_core {
 
 namespace {

data/src/core/lib/gprpp/global_config_generic.h

@@ -21,10 +21,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gprpp/memory.h"
-
 #include <stdint.h>
 
+#include "src/core/lib/gprpp/memory.h"
+
 #define GPR_GLOBAL_CONFIG_GET(name) gpr_global_config_get_##name()
 
 #define GPR_GLOBAL_CONFIG_SET(name, value) gpr_global_config_set_##name(value)

data/src/core/lib/gprpp/manual_constructor.h

@@ -25,12 +25,15 @@
 
 #include <stddef.h>
 #include <stdlib.h>
+
 #include <new>
 #include <type_traits>
 #include <utility>
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/construct_destruct.h"
+
 namespace grpc_core {
 
 // this contains templated helpers needed to implement the ManualConstructors
@@ -182,7 +185,7 @@ class ManualConstructor {
   Type& operator*() { return *get(); }
   const Type& operator*() const { return *get(); }
 
-  void Init() { new (&space_) Type; }
+  void Init() { Construct(get()); }
 
   // Init() constructs the Type instance using the given arguments
   // (which are forwarded to Type's constructor).
@@ -192,17 +195,17 @@ class ManualConstructor {
   // "new Type();"), so it will leave non-class types uninitialized.
   template <typename... Ts>
   void Init(Ts&&... args) {
-    new (&space_) Type(std::forward<Ts>(args)...);
+    Construct(get(), std::forward<Ts>(args)...);
   }
 
   // Init() that is equivalent to copy and move construction.
   // Enables usage like this:
   //   ManualConstructor<std::vector<int>> v;
   //   v.Init({1, 2, 3});
-  void Init(const Type& x) { new (&space_) Type(x); }
-  void Init(Type&& x) { new (&space_) Type(std::move(x)); }
+  void Init(const Type& x) { Construct(get(), x); }
+  void Init(Type&& x) { Construct(get(), std::forward<Type>(x)); }
 
-  void Destroy() { get()->~Type(); }
+  void Destroy() { Destruct(get()); }
 
  private:
   typename std::aligned_storage<sizeof(Type), alignof(Type)>::type space_;

data/src/core/lib/gprpp/match.h

@@ -0,0 +1,73 @@
+// Copyright 2021 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_CORE_LIB_GPRPP_MATCH_H
+#define GRPC_CORE_LIB_GPRPP_MATCH_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/types/variant.h"
+
+#include "src/core/lib/gprpp/overload.h"
+
+namespace grpc_core {
+
+namespace detail {
+
+template <typename... Cases>
+struct MatchPointerExtractor {
+  OverloadType<Cases...> cases;
+  template <typename T>
+  auto operator()(T& value) -> decltype(cases(&value)) {
+    return cases(&value);
+  }
+};
+
+}  // namespace detail
+
+/// Match on a variant.
+/// Given variant \a value, and a set of callables \a fs, call the appropriate
+/// callable based on the type contained in \a value.
+///
+/// Example (prints "hoorah"):
+///   variant<int, string> v = 42;
+///   Match(v,
+///         [](int i) { puts("hoorah"); },
+///         [](string s) { puts("boo"); });
+template <typename... Fs, typename T0, typename... Ts>
+auto Match(const absl::variant<T0, Ts...>& value, Fs... fs)
+    -> decltype(std::declval<OverloadType<Fs...>>()(std::declval<T0>())) {
+  return absl::visit(Overload(std::move(fs)...), value);
+}
+
+/// A version of Match that takes a mutable pointer to a variant and calls its
+/// overload callables with a mutable pointer to the current variant value.
+///
+/// Example:
+///   variant<int, string> v = 42;
+///   MatchMutable(&v,
+///                [](int* i) { *i = 1; },
+///                [](string* s) { *s = "foo"; });
+///   // v now contains 1.
+template <typename... Fs, typename T0, typename... Ts>
+auto MatchMutable(absl::variant<T0, Ts...>* value, Fs... fs)
+    -> decltype(std::declval<OverloadType<Fs...>>()(std::declval<T0*>())) {
+  return absl::visit(detail::MatchPointerExtractor<Fs...>{OverloadType<Fs...>(
+                         std::move(fs)...)},
+                     *value);
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_MATCH_H

data/src/core/lib/gprpp/memory.h

@@ -21,15 +21,15 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-
 #include <limits>
 #include <memory>
 #include <utility>
 
 #include "absl/memory/memory.h"
 
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
 namespace grpc_core {
 
 class DefaultDeleteChar {
@@ -46,6 +46,12 @@ class DefaultDeleteChar {
 template <typename T>
 using UniquePtr = std::unique_ptr<T, DefaultDeleteChar>;
 
+template <class T>
+T* Zalloc() {
+  static_assert(std::is_trivial<T>::value, "Type should be trivial");
+  return static_cast<T*>(gpr_zalloc(sizeof(T)));
+}
+
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_GPRPP_MEMORY_H */

data/src/core/lib/gprpp/mpscq.cc

@@ -27,9 +27,9 @@ namespace grpc_core {
 //
 
 bool MultiProducerSingleConsumerQueue::Push(Node* node) {
-  node->next.Store(nullptr, MemoryOrder::RELAXED);
-  Node* prev = head_.Exchange(node, MemoryOrder::ACQ_REL);
-  prev->next.Store(node, MemoryOrder::RELEASE);
+  node->next.store(nullptr, std::memory_order_relaxed);
+  Node* prev = head_.exchange(node, std::memory_order_acq_rel);
+  prev->next.store(node, std::memory_order_release);
   return prev == &stub_;
 }
 
@@ -42,7 +42,7 @@ MultiProducerSingleConsumerQueue::Pop() {
 MultiProducerSingleConsumerQueue::Node*
 MultiProducerSingleConsumerQueue::PopAndCheckEnd(bool* empty) {
   Node* tail = tail_;
-  Node* next = tail_->next.Load(MemoryOrder::ACQUIRE);
+  Node* next = tail_->next.load(std::memory_order_acquire);
   if (tail == &stub_) {
     // indicates the list is actually (ephemerally) empty
     if (next == nullptr) {
@@ -51,21 +51,21 @@ MultiProducerSingleConsumerQueue::PopAndCheckEnd(bool* empty) {
     }
     tail_ = next;
     tail = next;
-    next = tail->next.Load(MemoryOrder::ACQUIRE);
+    next = tail->next.load(std::memory_order_acquire);
   }
   if (next != nullptr) {
     *empty = false;
     tail_ = next;
     return tail;
   }
-  Node* head = head_.Load(MemoryOrder::ACQUIRE);
+  Node* head = head_.load(std::memory_order_acquire);
   if (tail != head) {
     *empty = false;
     // indicates a retry is in order: we're still adding
     return nullptr;
   }
   Push(&stub_);
-  next = tail->next.Load(MemoryOrder::ACQUIRE);
+  next = tail->next.load(std::memory_order_acquire);
   if (next != nullptr) {
     *empty = false;
     tail_ = next;

data/src/core/lib/gprpp/mpscq.h

@@ -21,11 +21,12 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gprpp/atomic.h"
-#include "src/core/lib/gprpp/sync.h"
+#include <atomic>
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/sync.h"
+
 namespace grpc_core {
 
 // Multiple-producer single-consumer lock free queue, based upon the
@@ -35,12 +36,12 @@ class MultiProducerSingleConsumerQueue {
  public:
   // List node.  Application node types can inherit from this.
   struct Node {
-    Atomic<Node*> next;
+    std::atomic<Node*> next{nullptr};
   };
 
   MultiProducerSingleConsumerQueue() : head_{&stub_}, tail_(&stub_) {}
   ~MultiProducerSingleConsumerQueue() {
-    GPR_ASSERT(head_.Load(MemoryOrder::RELAXED) == &stub_);
+    GPR_ASSERT(head_.load(std::memory_order_relaxed) == &stub_);
     GPR_ASSERT(tail_ == &stub_);
   }
 
@@ -61,7 +62,7 @@ class MultiProducerSingleConsumerQueue {
   // make sure head & tail don't share a cacheline
   union {
     char padding_[GPR_CACHELINE_SIZE];
-    Atomic<Node*> head_;
+    std::atomic<Node*> head_{nullptr};
   };
   Node* tail_;
   Node stub_;

data/src/core/lib/gprpp/orphanable.h

@@ -21,12 +21,12 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/log.h>
-#include <grpc/support/sync.h>
-
 #include <cinttypes>
 #include <memory>
 
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"