From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Sun, 7 Apr 2024 21:33:14 +0200
Subject: Adding upstream version 115.7.0esr.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 .../third_party/base/anglebase/no_destructor.h     | 106 +++++++++++++++++++++
 1 file changed, 106 insertions(+)
 create mode 100644 gfx/angle/checkout/src/common/third_party/base/anglebase/no_destructor.h

(limited to 'gfx/angle/checkout/src/common/third_party/base/anglebase/no_destructor.h')

diff --git a/gfx/angle/checkout/src/common/third_party/base/anglebase/no_destructor.h b/gfx/angle/checkout/src/common/third_party/base/anglebase/no_destructor.h
new file mode 100644
index 0000000000..5090dd9817
--- /dev/null
+++ b/gfx/angle/checkout/src/common/third_party/base/anglebase/no_destructor.h
@@ -0,0 +1,106 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ANGLEBASE_NO_DESTRUCTOR_H_
+#define ANGLEBASE_NO_DESTRUCTOR_H_
+
+#include <new>
+#include <utility>
+
+namespace angle
+{
+
+namespace base
+{
+
+// A wrapper that makes it easy to create an object of type T with static
+// storage duration that:
+// - is only constructed on first access
+// - never invokes the destructor
+// in order to satisfy the styleguide ban on global constructors and
+// destructors.
+//
+// Runtime constant example:
+// const std::string& GetLineSeparator() {
+//  // Forwards to std::string(size_t, char, const Allocator&) constructor.
+//   static const base::NoDestructor<std::string> s(5, '-');
+//   return *s;
+// }
+//
+// More complex initialization with a lambda:
+// const std::string& GetSessionNonce() {
+//   static const base::NoDestructor<std::string> nonce([] {
+//     std::string s(16);
+//     crypto::RandString(s.data(), s.size());
+//     return s;
+//   }());
+//   return *nonce;
+// }
+//
+// NoDestructor<T> stores the object inline, so it also avoids a pointer
+// indirection and a malloc. Also note that since C++11 static local variable
+// initialization is thread-safe and so is this pattern. Code should prefer to
+// use NoDestructor<T> over:
+// - A function scoped static T* or T& that is dynamically initialized.
+// - A global base::LazyInstance<T>.
+//
+// Note that since the destructor is never run, this *will* leak memory if used
+// as a stack or member variable. Furthermore, a NoDestructor<T> should never
+// have global scope as that may require a static initializer.
+template <typename T>
+class NoDestructor
+{
+  public:
+    // Not constexpr; just write static constexpr T x = ...; if the value should
+    // be a constexpr.
+    template <typename... Args>
+    explicit NoDestructor(Args &&... args)
+    {
+        new (storage_) T(std::forward<Args>(args)...);
+    }
+
+    // Allows copy and move construction of the contained type, to allow
+    // construction from an initializer list, e.g. for std::vector.
+    explicit NoDestructor(const T &x) { new (storage_) T(x); }
+    explicit NoDestructor(T &&x) { new (storage_) T(std::move(x)); }
+
+    NoDestructor(const NoDestructor &) = delete;
+    NoDestructor &operator=(const NoDestructor &) = delete;
+
+    ~NoDestructor() = default;
+
+    const T &operator*() const { return *get(); }
+    T &operator*() { return *get(); }
+
+    const T *operator->() const { return get(); }
+    T *operator->() { return get(); }
+
+    const T *get() const { return reinterpret_cast<const T *>(storage_); }
+    T *get() { return reinterpret_cast<T *>(storage_); }
+
+  private:
+    alignas(T) char storage_[sizeof(T)];
+
+#if defined(LEAK_SANITIZER)
+    // TODO(https://crbug.com/812277): This is a hack to work around the fact
+    // that LSan doesn't seem to treat NoDestructor as a root for reachability
+    // analysis. This means that code like this:
+    //   static base::NoDestructor<std::vector<int>> v({1, 2, 3});
+    // is considered a leak. Using the standard leak sanitizer annotations to
+    // suppress leaks doesn't work: std::vector is implicitly constructed before
+    // calling the base::NoDestructor constructor.
+    //
+    // Unfortunately, I haven't been able to demonstrate this issue in simpler
+    // reproductions: until that's resolved, hold an explicit pointer to the
+    // placement-new'd object in leak sanitizer mode to help LSan realize that
+    // objects allocated by the contained type are still reachable.
+    T *storage_ptr_ = reinterpret_cast<T *>(storage_);
+#endif  // defined(LEAK_SANITIZER)
+};
+
+}  // namespace base
+
+}  // namespace angle
+
+#endif  // ANGLEBASE_NO_DESTRUCTOR_H_
-- 
cgit v1.2.3