@nativescript/canvas 2.0.0-alpha.10 → 2.0.0-alpha.11

package/pods/Headers/include/cppgc/explicit-management.h

@@ -1,100 +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_EXPLICIT_MANAGEMENT_H_
-#define INCLUDE_CPPGC_EXPLICIT_MANAGEMENT_H_
-
-#include <cstddef>
-
-#include "cppgc/allocation.h"
-#include "cppgc/internal/logging.h"
-#include "cppgc/type-traits.h"
-
-namespace cppgc {
-
-class HeapHandle;
-
-namespace subtle {
-
-template <typename T>
-void FreeUnreferencedObject(HeapHandle& heap_handle, T& object);
-template <typename T>
-bool Resize(T& object, AdditionalBytes additional_bytes);
-
-}  // namespace subtle
-
-namespace internal {
-
-class ExplicitManagementImpl final {
- private:
-  V8_EXPORT static void FreeUnreferencedObject(HeapHandle&, void*);
-  V8_EXPORT static bool Resize(void*, size_t);
-
-  template <typename T>
-  friend void subtle::FreeUnreferencedObject(HeapHandle&, T&);
-  template <typename T>
-  friend bool subtle::Resize(T&, AdditionalBytes);
-};
-}  // namespace internal
-
-namespace subtle {
-
-/**
- * Informs the garbage collector that `object` can be immediately reclaimed. The
- * destructor may not be invoked immediately but only on next garbage
- * collection.
- *
- * It is up to the embedder to guarantee that no other object holds a reference
- * to `object` after calling `FreeUnreferencedObject()`. In case such a
- * reference exists, it's use results in a use-after-free.
- *
- * To aid in using the API, `FreeUnreferencedObject()` may be called from
- * destructors on objects that would be reclaimed in the same garbage collection
- * cycle.
- *
- * \param heap_handle The corresponding heap.
- * \param object Reference to an object that is of type `GarbageCollected` and
- *   should be immediately reclaimed.
- */
-template <typename T>
-void FreeUnreferencedObject(HeapHandle& heap_handle, T& object) {
-  static_assert(IsGarbageCollectedTypeV<T>,
-                "Object must be of type GarbageCollected.");
-  internal::ExplicitManagementImpl::FreeUnreferencedObject(heap_handle,
-                                                           &object);
-}
-
-/**
- * Tries to resize `object` of type `T` with additional bytes on top of
- * sizeof(T). Resizing is only useful with trailing inlined storage, see e.g.
- * `MakeGarbageCollected(AllocationHandle&, AdditionalBytes)`.
- *
- * `Resize()` performs growing or shrinking as needed and may skip the operation
- * for internal reasons, see return value.
- *
- * It is up to the embedder to guarantee that in case of shrinking a larger
- * object down, the reclaimed area is not used anymore. Any subsequent use
- * results in a use-after-free.
- *
- * The `object` must be live when calling `Resize()`.
- *
- * \param object Reference to an object that is of type `GarbageCollected` and
- *   should be resized.
- * \param additional_bytes Bytes in addition to sizeof(T) that the object should
- *   provide.
- * \returns true when the operation was successful and the result can be relied
- *   on, and false otherwise.
- */
-template <typename T>
-bool Resize(T& object, AdditionalBytes additional_bytes) {
-  static_assert(IsGarbageCollectedTypeV<T>,
-                "Object must be of type GarbageCollected.");
-  return internal::ExplicitManagementImpl::Resize(
-      &object, sizeof(T) + additional_bytes.value);
-}
-
-}  // namespace subtle
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_EXPLICIT_MANAGEMENT_H_

package/pods/Headers/include/cppgc/garbage-collected.h

@@ -1,106 +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_GARBAGE_COLLECTED_H_
-#define INCLUDE_CPPGC_GARBAGE_COLLECTED_H_
-
-#include "cppgc/internal/api-constants.h"
-#include "cppgc/platform.h"
-#include "cppgc/trace-trait.h"
-#include "cppgc/type-traits.h"
-
-namespace cppgc {
-
-class Visitor;
-
-/**
- * Base class for managed objects. Only descendent types of `GarbageCollected`
- * can be constructed using `MakeGarbageCollected()`. Must be inherited from as
- * left-most base class.
- *
- * Types inheriting from GarbageCollected must provide a method of
- * signature `void Trace(cppgc::Visitor*) const` that dispatchs all managed
- * pointers to the visitor and delegates to garbage-collected base classes.
- * The method must be virtual if the type is not directly a child of
- * GarbageCollected and marked as final.
- *
- * \code
- * // Example using final class.
- * class FinalType final : public GarbageCollected<FinalType> {
- *  public:
- *   void Trace(cppgc::Visitor* visitor) const {
- *     // Dispatch using visitor->Trace(...);
- *   }
- * };
- *
- * // Example using non-final base class.
- * class NonFinalBase : public GarbageCollected<NonFinalBase> {
- *  public:
- *   virtual void Trace(cppgc::Visitor*) const {}
- * };
- *
- * class FinalChild final : public NonFinalBase {
- *  public:
- *   void Trace(cppgc::Visitor* visitor) const final {
- *     // Dispatch using visitor->Trace(...);
- *     NonFinalBase::Trace(visitor);
- *   }
- * };
- * \endcode
- */
-template <typename T>
-class GarbageCollected {
- public:
-  using IsGarbageCollectedTypeMarker = void;
-  using ParentMostGarbageCollectedType = T;
-
-  // Must use MakeGarbageCollected.
-  void* operator new(size_t) = delete;
-  void* operator new[](size_t) = delete;
-  // The garbage collector is taking care of reclaiming the object. Also,
-  // virtual destructor requires an unambiguous, accessible 'operator delete'.
-  void operator delete(void*) {
-#ifdef V8_ENABLE_CHECKS
-    internal::Fatal(
-        "Manually deleting a garbage collected object is not allowed");
-#endif  // V8_ENABLE_CHECKS
-  }
-  void operator delete[](void*) = delete;
-
- protected:
-  GarbageCollected() = default;
-};
-
-/**
- * Base class for managed mixin objects. Such objects cannot be constructed
- * directly but must be mixed into the inheritance hierarchy of a
- * GarbageCollected object.
- *
- * Types inheriting from GarbageCollectedMixin must override a virtual method
- * of signature `void Trace(cppgc::Visitor*) const` that dispatchs all managed
- * pointers to the visitor and delegates to base classes.
- *
- * \code
- * class Mixin : public GarbageCollectedMixin {
- *  public:
- *   void Trace(cppgc::Visitor* visitor) const override {
- *     // Dispatch using visitor->Trace(...);
- *   }
- * };
- * \endcode
- */
-class GarbageCollectedMixin {
- public:
-  using IsGarbageCollectedMixinTypeMarker = void;
-
-  /**
-   * This Trace method must be overriden by objects inheriting from
-   * GarbageCollectedMixin.
-   */
-  virtual void Trace(cppgc::Visitor*) const {}
-};
-
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_GARBAGE_COLLECTED_H_

package/pods/Headers/include/cppgc/heap-consistency.h

@@ -1,266 +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_HEAP_CONSISTENCY_H_
-#define INCLUDE_CPPGC_HEAP_CONSISTENCY_H_
-
-#include <cstddef>
-
-#include "cppgc/internal/write-barrier.h"
-#include "cppgc/macros.h"
-#include "cppgc/trace-trait.h"
-#include "v8config.h"  // NOLINT(build/include_directory)
-
-namespace cppgc {
-
-class HeapHandle;
-
-namespace subtle {
-
-/**
- * **DO NOT USE: Use the appropriate managed types.**
- *
- * Consistency helpers that aid in maintaining a consistent internal state of
- * the garbage collector.
- */
-class HeapConsistency final {
- public:
-  using WriteBarrierParams = internal::WriteBarrier::Params;
-  using WriteBarrierType = internal::WriteBarrier::Type;
-
-  /**
-   * Gets the required write barrier type for a specific write.
-   *
-   * \param slot Slot containing the pointer to the object. The slot itself
-   *   must reside in an object that has been allocated using
-   *   `MakeGarbageCollected()`.
-   * \param value The pointer to the object. May be an interior pointer to an
-   *   interface of the actual object.
-   * \param params Parameters that may be used for actual write barrier calls.
-   *   Only filled if return value indicates that a write barrier is needed. The
-   *   contents of the `params` are an implementation detail.
-   * \returns whether a write barrier is needed and which barrier to invoke.
-   */
-  static V8_INLINE WriteBarrierType GetWriteBarrierType(
-      const void* slot, const void* value, WriteBarrierParams& params) {
-    return internal::WriteBarrier::GetWriteBarrierType(slot, value, params);
-  }
-
-  /**
-   * Gets the required write barrier type for a specific write.
-   *
-   * \param slot Slot to some part of an object. The object must not necessarily
-       have been allocated using `MakeGarbageCollected()` but can also live
-       off-heap or on stack.
-   * \param params Parameters that may be used for actual write barrier calls.
-   *   Only filled if return value indicates that a write barrier is needed. The
-   *   contents of the `params` are an implementation detail.
-   * \param callback Callback returning the corresponding heap handle. The
-   *   callback is only invoked if the heap cannot otherwise be figured out. The
-   *   callback must not allocate.
-   * \returns whether a write barrier is needed and which barrier to invoke.
-   */
-  template <typename HeapHandleCallback>
-  static V8_INLINE WriteBarrierType
-  GetWriteBarrierType(const void* slot, WriteBarrierParams& params,
-                      HeapHandleCallback callback) {
-    return internal::WriteBarrier::GetWriteBarrierType(slot, params, callback);
-  }
-
-  /**
-   * Gets the required write barrier type for a specific write.
-   * This version is meant to be used in conjunction with with a marking write
-   * barrier barrier which doesn't consider the slot.
-   *
-   * \param value The pointer to the object. May be an interior pointer to an
-   *   interface of the actual object.
-   * \param params Parameters that may be used for actual write barrier calls.
-   *   Only filled if return value indicates that a write barrier is needed. The
-   *   contents of the `params` are an implementation detail.
-   * \returns whether a write barrier is needed and which barrier to invoke.
-   */
-  static V8_INLINE WriteBarrierType
-  GetWriteBarrierType(const void* value, WriteBarrierParams& params) {
-    return internal::WriteBarrier::GetWriteBarrierType(value, params);
-  }
-
-  /**
-   * Conservative Dijkstra-style write barrier that processes an object if it
-   * has not yet been processed.
-   *
-   * \param params The parameters retrieved from `GetWriteBarrierType()`.
-   * \param object The pointer to the object. May be an interior pointer to a
-   *   an interface of the actual object.
-   */
-  static V8_INLINE void DijkstraWriteBarrier(const WriteBarrierParams& params,
-                                             const void* object) {
-    internal::WriteBarrier::DijkstraMarkingBarrier(params, object);
-  }
-
-  /**
-   * Conservative Dijkstra-style write barrier that processes a range of
-   * elements if they have not yet been processed.
-   *
-   * \param params The parameters retrieved from `GetWriteBarrierType()`.
-   * \param first_element Pointer to the first element that should be processed.
-   *   The slot itself must reside in an object that has been allocated using
-   *   `MakeGarbageCollected()`.
-   * \param element_size Size of the element in bytes.
-   * \param number_of_elements Number of elements that should be processed,
-   *   starting with `first_element`.
-   * \param trace_callback The trace callback that should be invoked for each
-   *   element if necessary.
-   */
-  static V8_INLINE void DijkstraWriteBarrierRange(
-      const WriteBarrierParams& params, const void* first_element,
-      size_t element_size, size_t number_of_elements,
-      TraceCallback trace_callback) {
-    internal::WriteBarrier::DijkstraMarkingBarrierRange(
-        params, first_element, element_size, number_of_elements,
-        trace_callback);
-  }
-
-  /**
-   * Steele-style write barrier that re-processes an object if it has already
-   * been processed.
-   *
-   * \param params The parameters retrieved from `GetWriteBarrierType()`.
-   * \param object The pointer to the object which must point to an object that
-   *   has been allocated using `MakeGarbageCollected()`. Interior pointers are
-   *   not supported.
-   */
-  static V8_INLINE void SteeleWriteBarrier(const WriteBarrierParams& params,
-                                           const void* object) {
-    internal::WriteBarrier::SteeleMarkingBarrier(params, object);
-  }
-
-  /**
-   * Generational barrier for maintaining consistency when running with multiple
-   * generations.
-   *
-   * \param params The parameters retrieved from `GetWriteBarrierType()`.
-   * \param slot Slot containing the pointer to the object. The slot itself
-   *   must reside in an object that has been allocated using
-   *   `MakeGarbageCollected()`.
-   */
-  static V8_INLINE void GenerationalBarrier(const WriteBarrierParams& params,
-                                            const void* slot) {
-    internal::WriteBarrier::GenerationalBarrier(params, slot);
-  }
-
-  /**
-   * Generational barrier for source object that may contain outgoing pointers
-   * to objects in young generation.
-   *
-   * \param params The parameters retrieved from `GetWriteBarrierType()`.
-   * \param inner_pointer Pointer to the source object.
-   */
-  static V8_INLINE void GenerationalBarrierForSourceObject(
-      const WriteBarrierParams& params, const void* inner_pointer) {
-    internal::WriteBarrier::GenerationalBarrierForSourceObject(params,
-                                                               inner_pointer);
-  }
-
- private:
-  HeapConsistency() = delete;
-};
-
-/**
- * Disallows garbage collection finalizations. Any garbage collection triggers
- * result in a crash when in this scope.
- *
- * Note that the garbage collector already covers paths that can lead to garbage
- * collections, so user code does not require checking
- * `IsGarbageCollectionAllowed()` before allocations.
- */
-class V8_EXPORT V8_NODISCARD DisallowGarbageCollectionScope final {
-  CPPGC_STACK_ALLOCATED();
-
- public:
-  /**
-   * \returns whether garbage collections are currently allowed.
-   */
-  static bool IsGarbageCollectionAllowed(HeapHandle& heap_handle);
-
-  /**
-   * Enters a disallow garbage collection scope. Must be paired with `Leave()`.
-   * Prefer a scope instance of `DisallowGarbageCollectionScope`.
-   *
-   * \param heap_handle The corresponding heap.
-   */
-  static void Enter(HeapHandle& heap_handle);
-
-  /**
-   * Leaves a disallow garbage collection scope. Must be paired with `Enter()`.
-   * Prefer a scope instance of `DisallowGarbageCollectionScope`.
-   *
-   * \param heap_handle The corresponding heap.
-   */
-  static void Leave(HeapHandle& heap_handle);
-
-  /**
-   * Constructs a scoped object that automatically enters and leaves a disallow
-   * garbage collection scope based on its lifetime.
-   *
-   * \param heap_handle The corresponding heap.
-   */
-  explicit DisallowGarbageCollectionScope(HeapHandle& heap_handle);
-  ~DisallowGarbageCollectionScope();
-
-  DisallowGarbageCollectionScope(const DisallowGarbageCollectionScope&) =
-      delete;
-  DisallowGarbageCollectionScope& operator=(
-      const DisallowGarbageCollectionScope&) = delete;
-
- private:
-  HeapHandle& heap_handle_;
-};
-
-/**
- * Avoids invoking garbage collection finalizations. Already running garbage
- * collection phase are unaffected by this scope.
- *
- * Should only be used temporarily as the scope has an impact on memory usage
- * and follow up garbage collections.
- */
-class V8_EXPORT V8_NODISCARD NoGarbageCollectionScope final {
-  CPPGC_STACK_ALLOCATED();
-
- public:
-  /**
-   * Enters a no garbage collection scope. Must be paired with `Leave()`. Prefer
-   * a scope instance of `NoGarbageCollectionScope`.
-   *
-   * \param heap_handle The corresponding heap.
-   */
-  static void Enter(HeapHandle& heap_handle);
-
-  /**
-   * Leaves a no garbage collection scope. Must be paired with `Enter()`. Prefer
-   * a scope instance of `NoGarbageCollectionScope`.
-   *
-   * \param heap_handle The corresponding heap.
-   */
-  static void Leave(HeapHandle& heap_handle);
-
-  /**
-   * Constructs a scoped object that automatically enters and leaves a no
-   * garbage collection scope based on its lifetime.
-   *
-   * \param heap_handle The corresponding heap.
-   */
-  explicit NoGarbageCollectionScope(HeapHandle& heap_handle);
-  ~NoGarbageCollectionScope();
-
-  NoGarbageCollectionScope(const NoGarbageCollectionScope&) = delete;
-  NoGarbageCollectionScope& operator=(const NoGarbageCollectionScope&) = delete;
-
- private:
-  HeapHandle& heap_handle_;
-};
-
-}  // namespace subtle
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_HEAP_CONSISTENCY_H_

package/pods/Headers/include/cppgc/heap-state.h

@@ -1,82 +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_HEAP_STATE_H_
-#define INCLUDE_CPPGC_HEAP_STATE_H_
-
-#include "v8config.h"  // NOLINT(build/include_directory)
-
-namespace cppgc {
-
-class HeapHandle;
-
-namespace subtle {
-
-/**
- * Helpers to peek into heap-internal state.
- */
-class V8_EXPORT HeapState final {
- public:
-  /**
-   * Returns whether the garbage collector is marking. This API is experimental
-   * and is expected to be removed in future.
-   *
-   * \param heap_handle The corresponding heap.
-   * \returns true if the garbage collector is currently marking, and false
-   *   otherwise.
-   */
-  static bool IsMarking(const HeapHandle& heap_handle);
-
-  /*
-   * Returns whether the garbage collector is sweeping. This API is experimental
-   * and is expected to be removed in future.
-   *
-   * \param heap_handle The corresponding heap.
-   * \returns true if the garbage collector is currently sweeping, and false
-   *   otherwise.
-   */
-  static bool IsSweeping(const HeapHandle& heap_handle);
-
-  /*
-   * Returns whether the garbage collector is currently sweeping on the thread
-   * owning this heap. This API allows the caller to determine whether it has
-   * been called from a destructor of a managed object. This API is experimental
-   * and may be removed in future.
-   *
-   * \param heap_handle The corresponding heap.
-   * \returns true if the garbage collector is currently sweeping on this
-   *   thread, and false otherwise.
-   */
-  static bool IsSweepingOnOwningThread(const HeapHandle& heap_handle);
-
-  /**
-   * Returns whether the garbage collector is in the atomic pause, i.e., the
-   * mutator is stopped from running. This API is experimental and is expected
-   * to be removed in future.
-   *
-   * \param heap_handle The corresponding heap.
-   * \returns true if the garbage collector is currently in the atomic pause,
-   *   and false otherwise.
-   */
-  static bool IsInAtomicPause(const HeapHandle& heap_handle);
-
-  /**
-   * Returns whether the last garbage collection was finalized conservatively
-   * (i.e., with a non-empty stack). This API is experimental and is expected to
-   * be removed in future.
-   *
-   * \param heap_handle The corresponding heap.
-   * \returns true if the last garbage collection was finalized conservatively,
-   * and false otherwise.
-   */
-  static bool PreviousGCWasConservative(const HeapHandle& heap_handle);
-
- private:
-  HeapState() = delete;
-};
-
-}  // namespace subtle
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_HEAP_STATE_H_

package/pods/Headers/include/cppgc/heap-statistics.h

@@ -1,120 +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_HEAP_STATISTICS_H_
-#define INCLUDE_CPPGC_HEAP_STATISTICS_H_
-
-#include <cstddef>
-#include <cstdint>
-#include <string>
-#include <vector>
-
-namespace cppgc {
-
-/**
- * `HeapStatistics` contains memory consumption and utilization statistics for a
- * cppgc heap.
- */
-struct HeapStatistics final {
-  /**
-   * Specifies the detail level of the heap statistics. Brief statistics contain
-   * only the top-level allocated and used memory statistics for the entire
-   * heap. Detailed statistics also contain a break down per space and page, as
-   * well as freelist statistics and object type histograms. Note that used
-   * memory reported by brief statistics and detailed statistics might differ
-   * slightly.
-   */
-  enum DetailLevel : uint8_t {
-    kBrief,
-    kDetailed,
-  };
-
-  /**
-   * Object statistics for a single type.
-   */
-  struct ObjectStatsEntry {
-    /**
-     * Number of allocated bytes.
-     */
-    size_t allocated_bytes;
-    /**
-     * Number of allocated objects.
-     */
-    size_t object_count;
-  };
-
-  /**
-   * Page granularity statistics. For each page the statistics record the
-   * allocated memory size and overall used memory size for the page.
-   */
-  struct PageStatistics {
-    /** Overall committed amount of memory for the page. */
-    size_t committed_size_bytes = 0;
-    /** Resident amount of memory held by the page. */
-    size_t resident_size_bytes = 0;
-    /** Amount of memory actually used on the page. */
-    size_t used_size_bytes = 0;
-    /** Statistics for object allocated on the page. Filled only when
-     * NameProvider::HideInternalNames() is false. */
-    std::vector<ObjectStatsEntry> object_statistics;
-  };
-
-  /**
-   * Statistics of the freelist (used only in non-large object spaces). For
-   * each bucket in the freelist the statistics record the bucket size, the
-   * number of freelist entries in the bucket, and the overall allocated memory
-   * consumed by these freelist entries.
-   */
-  struct FreeListStatistics {
-    /** bucket sizes in the freelist. */
-    std::vector<size_t> bucket_size;
-    /** number of freelist entries per bucket. */
-    std::vector<size_t> free_count;
-    /** memory size consumed by freelist entries per size. */
-    std::vector<size_t> free_size;
-  };
-
-  /**
-   * Space granularity statistics. For each space the statistics record the
-   * space name, the amount of allocated memory and overall used memory for the
-   * space. The statistics also contain statistics for each of the space's
-   * pages, its freelist and the objects allocated on the space.
-   */
-  struct SpaceStatistics {
-    /** The space name */
-    std::string name;
-    /** Overall committed amount of memory for the heap. */
-    size_t committed_size_bytes = 0;
-    /** Resident amount of memory held by the heap. */
-    size_t resident_size_bytes = 0;
-    /** Amount of memory actually used on the space. */
-    size_t used_size_bytes = 0;
-    /** Statistics for each of the pages in the space. */
-    std::vector<PageStatistics> page_stats;
-    /** Statistics for the freelist of the space. */
-    FreeListStatistics free_list_stats;
-  };
-
-  /** Overall committed amount of memory for the heap. */
-  size_t committed_size_bytes = 0;
-  /** Resident amount of memory help by the heap. */
-  size_t resident_size_bytes = 0;
-  /** Amount of memory actually used on the heap. */
-  size_t used_size_bytes = 0;
-  /** Detail level of this HeapStatistics. */
-  DetailLevel detail_level;
-
-  /** Statistics for each of the spaces in the heap. Filled only when
-   * `detail_level` is `DetailLevel::kDetailed`. */
-  std::vector<SpaceStatistics> space_stats;
-
-  /**
-   * Vector of `cppgc::GarbageCollected` type names.
-   */
-  std::vector<std::string> type_names;
-};
-
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_HEAP_STATISTICS_H_