@triniwiz/nativescript-masonkit 1.0.0-alpha.12 → 1.0.0-alpha.14

package/src-native/pods/Headers/include/cppgc/persistent.h

@@ -1,370 +0,0 @@
-// Copyright 2020 the V8 project 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 INCLUDE_CPPGC_PERSISTENT_H_
-#define INCLUDE_CPPGC_PERSISTENT_H_
-
-#include <type_traits>
-
-#include "cppgc/internal/persistent-node.h"
-#include "cppgc/internal/pointer-policies.h"
-#include "cppgc/sentinel-pointer.h"
-#include "cppgc/source-location.h"
-#include "cppgc/type-traits.h"
-#include "cppgc/visitor.h"
-#include "v8config.h"  // NOLINT(build/include_directory)
-
-namespace cppgc {
-
-class Visitor;
-
-namespace internal {
-
-// PersistentBase always refers to the object as const object and defers to
-// BasicPersistent on casting to the right type as needed.
-class PersistentBase {
- protected:
-  PersistentBase() = default;
-  explicit PersistentBase(const void* raw) : raw_(raw) {}
-
-  const void* GetValue() const { return raw_; }
-  void SetValue(const void* value) { raw_ = value; }
-
-  PersistentNode* GetNode() const { return node_; }
-  void SetNode(PersistentNode* node) { node_ = node; }
-
-  // Performs a shallow clear which assumes that internal persistent nodes are
-  // destroyed elsewhere.
-  void ClearFromGC() const {
-    raw_ = nullptr;
-    node_ = nullptr;
-  }
-
- protected:
-  mutable const void* raw_ = nullptr;
-  mutable PersistentNode* node_ = nullptr;
-
-  friend class PersistentRegionBase;
-};
-
-// The basic class from which all Persistent classes are generated.
-template <typename T, typename WeaknessPolicy, typename LocationPolicy,
-          typename CheckingPolicy>
-class BasicPersistent final : public PersistentBase,
-                              public LocationPolicy,
-                              private WeaknessPolicy,
-                              private CheckingPolicy {
- public:
-  using typename WeaknessPolicy::IsStrongPersistent;
-  using PointeeType = T;
-
-  // Null-state/sentinel constructors.
-  BasicPersistent(  // NOLINT
-      const SourceLocation& loc = SourceLocation::Current())
-      : LocationPolicy(loc) {}
-
-  BasicPersistent(std::nullptr_t,  // NOLINT
-                  const SourceLocation& loc = SourceLocation::Current())
-      : LocationPolicy(loc) {}
-
-  BasicPersistent(  // NOLINT
-      SentinelPointer s, const SourceLocation& loc = SourceLocation::Current())
-      : PersistentBase(s), LocationPolicy(loc) {}
-
-  // Raw value constructors.
-  BasicPersistent(T* raw,  // NOLINT
-                  const SourceLocation& loc = SourceLocation::Current())
-      : PersistentBase(raw), LocationPolicy(loc) {
-    if (!IsValid()) return;
-    SetNode(WeaknessPolicy::GetPersistentRegion(GetValue())
-                .AllocateNode(this, &BasicPersistent::Trace));
-    this->CheckPointer(Get());
-  }
-
-  BasicPersistent(T& raw,  // NOLINT
-                  const SourceLocation& loc = SourceLocation::Current())
-      : BasicPersistent(&raw, loc) {}
-
-  // Copy ctor.
-  BasicPersistent(const BasicPersistent& other,
-                  const SourceLocation& loc = SourceLocation::Current())
-      : BasicPersistent(other.Get(), loc) {}
-
-  // Heterogeneous ctor.
-  template <typename U, typename OtherWeaknessPolicy,
-            typename OtherLocationPolicy, typename OtherCheckingPolicy,
-            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicPersistent(
-      const BasicPersistent<U, OtherWeaknessPolicy, OtherLocationPolicy,
-                            OtherCheckingPolicy>& other,
-      const SourceLocation& loc = SourceLocation::Current())
-      : BasicPersistent(other.Get(), loc) {}
-
-  // Move ctor. The heterogeneous move ctor is not supported since e.g.
-  // persistent can't reuse persistent node from weak persistent.
-  BasicPersistent(
-      BasicPersistent&& other,
-      const SourceLocation& loc = SourceLocation::Current()) noexcept
-      : PersistentBase(std::move(other)), LocationPolicy(std::move(other)) {
-    if (!IsValid()) return;
-    GetNode()->UpdateOwner(this);
-    other.SetValue(nullptr);
-    other.SetNode(nullptr);
-    this->CheckPointer(Get());
-  }
-
-  // Constructor from member.
-  template <typename U, typename MemberBarrierPolicy,
-            typename MemberWeaknessTag, typename MemberCheckingPolicy,
-            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicPersistent(
-      const internal::BasicMember<U, MemberBarrierPolicy, MemberWeaknessTag,
-                                  MemberCheckingPolicy>& member,
-      const SourceLocation& loc = SourceLocation::Current())
-      : BasicPersistent(member.Get(), loc) {}
-
-  ~BasicPersistent() { Clear(); }
-
-  // Copy assignment.
-  BasicPersistent& operator=(const BasicPersistent& other) {
-    return operator=(other.Get());
-  }
-
-  template <typename U, typename OtherWeaknessPolicy,
-            typename OtherLocationPolicy, typename OtherCheckingPolicy,
-            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicPersistent& operator=(
-      const BasicPersistent<U, OtherWeaknessPolicy, OtherLocationPolicy,
-                            OtherCheckingPolicy>& other) {
-    return operator=(other.Get());
-  }
-
-  // Move assignment.
-  BasicPersistent& operator=(BasicPersistent&& other) noexcept {
-    if (this == &other) return *this;
-    Clear();
-    PersistentBase::operator=(std::move(other));
-    LocationPolicy::operator=(std::move(other));
-    if (!IsValid()) return *this;
-    GetNode()->UpdateOwner(this);
-    other.SetValue(nullptr);
-    other.SetNode(nullptr);
-    this->CheckPointer(Get());
-    return *this;
-  }
-
-  // Assignment from member.
-  template <typename U, typename MemberBarrierPolicy,
-            typename MemberWeaknessTag, typename MemberCheckingPolicy,
-            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
-  BasicPersistent& operator=(
-      const internal::BasicMember<U, MemberBarrierPolicy, MemberWeaknessTag,
-                                  MemberCheckingPolicy>& member) {
-    return operator=(member.Get());
-  }
-
-  BasicPersistent& operator=(T* other) {
-    Assign(other);
-    return *this;
-  }
-
-  BasicPersistent& operator=(std::nullptr_t) {
-    Clear();
-    return *this;
-  }
-
-  BasicPersistent& operator=(SentinelPointer s) {
-    Assign(s);
-    return *this;
-  }
-
-  explicit operator bool() const { return Get(); }
-  operator T*() const { return Get(); }
-  T* operator->() const { return Get(); }
-  T& operator*() const { return *Get(); }
-
-  // CFI cast exemption to allow passing SentinelPointer through T* and support
-  // heterogeneous assignments between different Member and Persistent handles
-  // based on their actual types.
-  V8_CLANG_NO_SANITIZE("cfi-unrelated-cast") T* Get() const {
-    // The const_cast below removes the constness from PersistentBase storage.
-    // The following static_cast re-adds any constness if specified through the
-    // user-visible template parameter T.
-    return static_cast<T*>(const_cast<void*>(GetValue()));
-  }
-
-  void Clear() {
-    // Simplified version of `Assign()` to allow calling without a complete type
-    // `T`.
-    if (IsValid()) {
-      WeaknessPolicy::GetPersistentRegion(GetValue()).FreeNode(GetNode());
-      SetNode(nullptr);
-    }
-    SetValue(nullptr);
-  }
-
-  T* Release() {
-    T* result = Get();
-    Clear();
-    return result;
-  }
-
-  template <typename U, typename OtherWeaknessPolicy = WeaknessPolicy,
-            typename OtherLocationPolicy = LocationPolicy,
-            typename OtherCheckingPolicy = CheckingPolicy>
-  BasicPersistent<U, OtherWeaknessPolicy, OtherLocationPolicy,
-                  OtherCheckingPolicy>
-  To() const {
-    return BasicPersistent<U, OtherWeaknessPolicy, OtherLocationPolicy,
-                           OtherCheckingPolicy>(static_cast<U*>(Get()));
-  }
-
- private:
-  static void Trace(Visitor* v, const void* ptr) {
-    const auto* persistent = static_cast<const BasicPersistent*>(ptr);
-    v->TraceRoot(*persistent, persistent->Location());
-  }
-
-  bool IsValid() const {
-    // Ideally, handling kSentinelPointer would be done by the embedder. On the
-    // other hand, having Persistent aware of it is beneficial since no node
-    // gets wasted.
-    return GetValue() != nullptr && GetValue() != kSentinelPointer;
-  }
-
-  void Assign(T* ptr) {
-    if (IsValid()) {
-      if (ptr && ptr != kSentinelPointer) {
-        // Simply assign the pointer reusing the existing node.
-        SetValue(ptr);
-        this->CheckPointer(ptr);
-        return;
-      }
-      WeaknessPolicy::GetPersistentRegion(GetValue()).FreeNode(GetNode());
-      SetNode(nullptr);
-    }
-    SetValue(ptr);
-    if (!IsValid()) return;
-    SetNode(WeaknessPolicy::GetPersistentRegion(GetValue())
-                .AllocateNode(this, &BasicPersistent::Trace));
-    this->CheckPointer(Get());
-  }
-
-  void ClearFromGC() const {
-    if (IsValid()) {
-      WeaknessPolicy::GetPersistentRegion(GetValue()).FreeNode(GetNode());
-      PersistentBase::ClearFromGC();
-    }
-  }
-
-  // Set Get() for details.
-  V8_CLANG_NO_SANITIZE("cfi-unrelated-cast")
-  T* GetFromGC() const {
-    return static_cast<T*>(const_cast<void*>(GetValue()));
-  }
-
-  friend class cppgc::Visitor;
-};
-
-template <typename T1, typename WeaknessPolicy1, typename LocationPolicy1,
-          typename CheckingPolicy1, typename T2, typename WeaknessPolicy2,
-          typename LocationPolicy2, typename CheckingPolicy2>
-bool operator==(const BasicPersistent<T1, WeaknessPolicy1, LocationPolicy1,
-                                      CheckingPolicy1>& p1,
-                const BasicPersistent<T2, WeaknessPolicy2, LocationPolicy2,
-                                      CheckingPolicy2>& p2) {
-  return p1.Get() == p2.Get();
-}
-
-template <typename T1, typename WeaknessPolicy1, typename LocationPolicy1,
-          typename CheckingPolicy1, typename T2, typename WeaknessPolicy2,
-          typename LocationPolicy2, typename CheckingPolicy2>
-bool operator!=(const BasicPersistent<T1, WeaknessPolicy1, LocationPolicy1,
-                                      CheckingPolicy1>& p1,
-                const BasicPersistent<T2, WeaknessPolicy2, LocationPolicy2,
-                                      CheckingPolicy2>& p2) {
-  return !(p1 == p2);
-}
-
-template <typename T1, typename PersistentWeaknessPolicy,
-          typename PersistentLocationPolicy, typename PersistentCheckingPolicy,
-          typename T2, typename MemberWriteBarrierPolicy,
-          typename MemberWeaknessTag, typename MemberCheckingPolicy>
-bool operator==(
-    const BasicPersistent<T1, PersistentWeaknessPolicy,
-                          PersistentLocationPolicy, PersistentCheckingPolicy>&
-        p,
-    const BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
-                      MemberCheckingPolicy>& m) {
-  return p.Get() == m.Get();
-}
-
-template <typename T1, typename PersistentWeaknessPolicy,
-          typename PersistentLocationPolicy, typename PersistentCheckingPolicy,
-          typename T2, typename MemberWriteBarrierPolicy,
-          typename MemberWeaknessTag, typename MemberCheckingPolicy>
-bool operator!=(
-    const BasicPersistent<T1, PersistentWeaknessPolicy,
-                          PersistentLocationPolicy, PersistentCheckingPolicy>&
-        p,
-    const BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
-                      MemberCheckingPolicy>& m) {
-  return !(p == m);
-}
-
-template <typename T1, typename MemberWriteBarrierPolicy,
-          typename MemberWeaknessTag, typename MemberCheckingPolicy,
-          typename T2, typename PersistentWeaknessPolicy,
-          typename PersistentLocationPolicy, typename PersistentCheckingPolicy>
-bool operator==(
-    const BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
-                      MemberCheckingPolicy>& m,
-    const BasicPersistent<T1, PersistentWeaknessPolicy,
-                          PersistentLocationPolicy, PersistentCheckingPolicy>&
-        p) {
-  return m.Get() == p.Get();
-}
-
-template <typename T1, typename MemberWriteBarrierPolicy,
-          typename MemberWeaknessTag, typename MemberCheckingPolicy,
-          typename T2, typename PersistentWeaknessPolicy,
-          typename PersistentLocationPolicy, typename PersistentCheckingPolicy>
-bool operator!=(
-    const BasicMember<T2, MemberWeaknessTag, MemberWriteBarrierPolicy,
-                      MemberCheckingPolicy>& m,
-    const BasicPersistent<T1, PersistentWeaknessPolicy,
-                          PersistentLocationPolicy, PersistentCheckingPolicy>&
-        p) {
-  return !(m == p);
-}
-
-template <typename T, typename LocationPolicy, typename CheckingPolicy>
-struct IsWeak<BasicPersistent<T, internal::WeakPersistentPolicy, LocationPolicy,
-                              CheckingPolicy>> : std::true_type {};
-}  // namespace internal
-
-/**
- * Persistent is a way to create a strong pointer from an off-heap object to
- * another on-heap object. As long as the Persistent handle is alive the GC will
- * keep the object pointed to alive. The Persistent handle is always a GC root
- * from the point of view of the GC. Persistent must be constructed and
- * destructed in the same thread.
- */
-template <typename T>
-using Persistent =
-    internal::BasicPersistent<T, internal::StrongPersistentPolicy>;
-
-/**
- * WeakPersistent is a way to create a weak pointer from an off-heap object to
- * an on-heap object. The pointer is automatically cleared when the pointee gets
- * collected. WeakPersistent must be constructed and destructed in the same
- * thread.
- */
-template <typename T>
-using WeakPersistent =
-    internal::BasicPersistent<T, internal::WeakPersistentPolicy>;
-
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_PERSISTENT_H_

package/src-native/pods/Headers/include/cppgc/platform.h

@@ -1,156 +0,0 @@
-// Copyright 2020 the V8 project 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 INCLUDE_CPPGC_PLATFORM_H_
-#define INCLUDE_CPPGC_PLATFORM_H_
-
-#include <memory>
-
-#include "cppgc/source-location.h"
-#include "v8-platform.h"  // NOLINT(build/include_directory)
-#include "v8config.h"     // NOLINT(build/include_directory)
-
-namespace cppgc {
-
-// TODO(v8:10346): Create separate includes for concepts that are not
-// V8-specific.
-using IdleTask = v8::IdleTask;
-using JobHandle = v8::JobHandle;
-using JobDelegate = v8::JobDelegate;
-using JobTask = v8::JobTask;
-using PageAllocator = v8::PageAllocator;
-using Task = v8::Task;
-using TaskPriority = v8::TaskPriority;
-using TaskRunner = v8::TaskRunner;
-using TracingController = v8::TracingController;
-
-/**
- * Platform interface used by Heap. Contains allocators and executors.
- */
-class V8_EXPORT Platform {
- public:
-  virtual ~Platform() = default;
-
-  /**
-   * Returns the allocator used by cppgc to allocate its heap and various
-   * support structures.
-   */
-  virtual PageAllocator* GetPageAllocator() = 0;
-
-  /**
-   * Monotonically increasing time in seconds from an arbitrary fixed point in
-   * the past. This function is expected to return at least
-   * millisecond-precision values. For this reason,
-   * it is recommended that the fixed point be no further in the past than
-   * the epoch.
-   **/
-  virtual double MonotonicallyIncreasingTime() = 0;
-
-  /**
-   * Foreground task runner that should be used by a Heap.
-   */
-  virtual std::shared_ptr<TaskRunner> GetForegroundTaskRunner() {
-    return nullptr;
-  }
-
-  /**
-   * Posts `job_task` to run in parallel. Returns a `JobHandle` associated with
-   * the `Job`, which can be joined or canceled.
-   * This avoids degenerate cases:
-   * - Calling `CallOnWorkerThread()` for each work item, causing significant
-   *   overhead.
-   * - Fixed number of `CallOnWorkerThread()` calls that split the work and
-   *   might run for a long time. This is problematic when many components post
-   *   "num cores" tasks and all expect to use all the cores. In these cases,
-   *   the scheduler lacks context to be fair to multiple same-priority requests
-   *   and/or ability to request lower priority work to yield when high priority
-   *   work comes in.
-   * A canonical implementation of `job_task` looks like:
-   * \code
-   * class MyJobTask : public JobTask {
-   *  public:
-   *   MyJobTask(...) : worker_queue_(...) {}
-   *   // JobTask implementation.
-   *   void Run(JobDelegate* delegate) override {
-   *     while (!delegate->ShouldYield()) {
-   *       // Smallest unit of work.
-   *       auto work_item = worker_queue_.TakeWorkItem(); // Thread safe.
-   *       if (!work_item) return;
-   *       ProcessWork(work_item);
-   *     }
-   *   }
-   *
-   *   size_t GetMaxConcurrency() const override {
-   *     return worker_queue_.GetSize(); // Thread safe.
-   *   }
-   * };
-   *
-   * // ...
-   * auto handle = PostJob(TaskPriority::kUserVisible,
-   *                       std::make_unique<MyJobTask>(...));
-   * handle->Join();
-   * \endcode
-   *
-   * `PostJob()` and methods of the returned JobHandle/JobDelegate, must never
-   * be called while holding a lock that could be acquired by `JobTask::Run()`
-   * or `JobTask::GetMaxConcurrency()` -- that could result in a deadlock. This
-   * is because (1) `JobTask::GetMaxConcurrency()` may be invoked while holding
-   * internal lock (A), hence `JobTask::GetMaxConcurrency()` can only use a lock
-   * (B) if that lock is *never* held while calling back into `JobHandle` from
-   * any thread (A=>B/B=>A deadlock) and (2) `JobTask::Run()` or
-   * `JobTask::GetMaxConcurrency()` may be invoked synchronously from
-   * `JobHandle` (B=>JobHandle::foo=>B deadlock).
-   *
-   * A sufficient `PostJob()` implementation that uses the default Job provided
-   * in libplatform looks like:
-   * \code
-   * std::unique_ptr<JobHandle> PostJob(
-   *     TaskPriority priority, std::unique_ptr<JobTask> job_task) override {
-   *   return std::make_unique<DefaultJobHandle>(
-   *       std::make_shared<DefaultJobState>(
-   *           this, std::move(job_task), kNumThreads));
-   * }
-   * \endcode
-   */
-  virtual std::unique_ptr<JobHandle> PostJob(
-      TaskPriority priority, std::unique_ptr<JobTask> job_task) {
-    return nullptr;
-  }
-
-  /**
-   * Returns an instance of a `TracingController`. This must be non-nullptr. The
-   * default implementation returns an empty `TracingController` that consumes
-   * trace data without effect.
-   */
-  virtual TracingController* GetTracingController();
-};
-
-/**
- * Process-global initialization of the garbage collector. Must be called before
- * creating a Heap.
- *
- * Can be called multiple times when paired with `ShutdownProcess()`.
- *
- * \param page_allocator The allocator used for maintaining meta data. Must not
- *   change between multiple calls to InitializeProcess.
- */
-V8_EXPORT void InitializeProcess(PageAllocator* page_allocator);
-
-/**
- * Must be called after destroying the last used heap. Some process-global
- * metadata may not be returned and reused upon a subsequent
- * `InitializeProcess()` call.
- */
-V8_EXPORT void ShutdownProcess();
-
-namespace internal {
-
-V8_EXPORT void Fatal(const std::string& reason = std::string(),
-                     const SourceLocation& = SourceLocation::Current());
-
-}  // namespace internal
-
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_PLATFORM_H_

package/src-native/pods/Headers/include/cppgc/prefinalizer.h

@@ -1,75 +0,0 @@
-// Copyright 2020 the V8 project 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 INCLUDE_CPPGC_PREFINALIZER_H_
-#define INCLUDE_CPPGC_PREFINALIZER_H_
-
-#include "cppgc/internal/compiler-specific.h"
-#include "cppgc/liveness-broker.h"
-
-namespace cppgc {
-
-namespace internal {
-
-class V8_EXPORT PrefinalizerRegistration final {
- public:
-  using Callback = bool (*)(const cppgc::LivenessBroker&, void*);
-
-  PrefinalizerRegistration(void*, Callback);
-
-  void* operator new(size_t, void* location) = delete;
-  void* operator new(size_t) = delete;
-};
-
-}  // namespace internal
-
-/**
- * Macro must be used in the private section of `Class` and registers a
- * prefinalization callback `void Class::PreFinalizer()`. The callback is
- * invoked on garbage collection after the collector has found an object to be
- * dead.
- *
- * Callback properties:
- * - The callback is invoked before a possible destructor for the corresponding
- *   object.
- * - The callback may access the whole object graph, irrespective of whether
- *   objects are considered dead or alive.
- * - The callback is invoked on the same thread as the object was created on.
- *
- * Example:
- * \code
- * class WithPrefinalizer : public GarbageCollected<WithPrefinalizer> {
- *   CPPGC_USING_PRE_FINALIZER(WithPrefinalizer, Dispose);
- *
- *  public:
- *   void Trace(Visitor*) const {}
- *   void Dispose() { prefinalizer_called = true; }
- *   ~WithPrefinalizer() {
- *     // prefinalizer_called == true
- *   }
- *  private:
- *   bool prefinalizer_called = false;
- * };
- * \endcode
- */
-#define CPPGC_USING_PRE_FINALIZER(Class, PreFinalizer)                         \
- public:                                                                       \
-  static bool InvokePreFinalizer(const cppgc::LivenessBroker& liveness_broker, \
-                                 void* object) {                               \
-    static_assert(cppgc::IsGarbageCollectedOrMixinTypeV<Class>,                \
-                  "Only garbage collected objects can have prefinalizers");    \
-    Class* self = static_cast<Class*>(object);                                 \
-    if (liveness_broker.IsHeapObjectAlive(self)) return false;                 \
-    self->PreFinalizer();                                                      \
-    return true;                                                               \
-  }                                                                            \
-                                                                               \
- private:                                                                      \
-  CPPGC_NO_UNIQUE_ADDRESS cppgc::internal::PrefinalizerRegistration            \
-      prefinalizer_dummy_{this, Class::InvokePreFinalizer};                    \
-  static_assert(true, "Force semicolon.")
-
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_PREFINALIZER_H_

package/src-native/pods/Headers/include/cppgc/process-heap-statistics.h

@@ -1,36 +0,0 @@
-// Copyright 2020 the V8 project 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 INCLUDE_CPPGC_PROCESS_HEAP_STATISTICS_H_
-#define INCLUDE_CPPGC_PROCESS_HEAP_STATISTICS_H_
-
-#include <atomic>
-#include <cstddef>
-
-#include "v8config.h"  // NOLINT(build/include_directory)
-
-namespace cppgc {
-namespace internal {
-class ProcessHeapStatisticsUpdater;
-}  // namespace internal
-
-class V8_EXPORT ProcessHeapStatistics final {
- public:
-  static size_t TotalAllocatedObjectSize() {
-    return total_allocated_object_size_.load(std::memory_order_relaxed);
-  }
-  static size_t TotalAllocatedSpace() {
-    return total_allocated_space_.load(std::memory_order_relaxed);
-  }
-
- private:
-  static std::atomic_size_t total_allocated_space_;
-  static std::atomic_size_t total_allocated_object_size_;
-
-  friend class internal::ProcessHeapStatisticsUpdater;
-};
-
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_PROCESS_HEAP_STATISTICS_H_

package/src-native/pods/Headers/include/cppgc/sentinel-pointer.h

@@ -1,32 +0,0 @@
-// Copyright 2021 the V8 project 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 INCLUDE_CPPGC_SENTINEL_POINTER_H_
-#define INCLUDE_CPPGC_SENTINEL_POINTER_H_
-
-#include <cstdint>
-
-namespace cppgc {
-namespace internal {
-
-// Special tag type used to denote some sentinel member. The semantics of the
-// sentinel is defined by the embedder.
-struct SentinelPointer {
-  template <typename T>
-  operator T*() const {
-    static constexpr intptr_t kSentinelValue = 1;
-    return reinterpret_cast<T*>(kSentinelValue);
-  }
-  // Hidden friends.
-  friend bool operator==(SentinelPointer, SentinelPointer) { return true; }
-  friend bool operator!=(SentinelPointer, SentinelPointer) { return false; }
-};
-
-}  // namespace internal
-
-constexpr internal::SentinelPointer kSentinelPointer;
-
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_SENTINEL_POINTER_H_