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

package/pods/Headers/include/cppgc/internal/logging.h

@@ -1,50 +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_INTERNAL_LOGGING_H_
-#define INCLUDE_CPPGC_INTERNAL_LOGGING_H_
-
-#include "cppgc/source-location.h"
-#include "v8config.h"  // NOLINT(build/include_directory)
-
-namespace cppgc {
-namespace internal {
-
-void V8_EXPORT DCheckImpl(const char*,
-                          const SourceLocation& = SourceLocation::Current());
-[[noreturn]] void V8_EXPORT
-FatalImpl(const char*, const SourceLocation& = SourceLocation::Current());
-
-// Used to ignore -Wunused-variable.
-template <typename>
-struct EatParams {};
-
-#if defined(DEBUG)
-#define CPPGC_DCHECK_MSG(condition, message)  \
-  do {                                        \
-    if (V8_UNLIKELY(!(condition))) {          \
-      ::cppgc::internal::DCheckImpl(message); \
-    }                                         \
-  } while (false)
-#else  // !defined(DEBUG)
-#define CPPGC_DCHECK_MSG(condition, message)                \
-  (static_cast<void>(::cppgc::internal::EatParams<decltype( \
-                         static_cast<void>(condition), message)>{}))
-#endif  // !defined(DEBUG)
-
-#define CPPGC_DCHECK(condition) CPPGC_DCHECK_MSG(condition, #condition)
-
-#define CPPGC_CHECK_MSG(condition, message)  \
-  do {                                       \
-    if (V8_UNLIKELY(!(condition))) {         \
-      ::cppgc::internal::FatalImpl(message); \
-    }                                        \
-  } while (false)
-
-#define CPPGC_CHECK(condition) CPPGC_CHECK_MSG(condition, #condition)
-
-}  // namespace internal
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_INTERNAL_LOGGING_H_

package/pods/Headers/include/cppgc/internal/name-trait.h

@@ -1,122 +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_INTERNAL_NAME_TRAIT_H_
-#define INCLUDE_CPPGC_INTERNAL_NAME_TRAIT_H_
-
-#include <cstddef>
-#include <type_traits>
-
-#include "cppgc/name-provider.h"
-#include "v8config.h"  // NOLINT(build/include_directory)
-
-namespace cppgc {
-namespace internal {
-
-#if CPPGC_SUPPORTS_OBJECT_NAMES && defined(__clang__)
-#define CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME 1
-
-// Provides constexpr c-string storage for a name of fixed |Size| characters.
-// Automatically appends terminating 0 byte.
-template <size_t Size>
-struct NameBuffer {
-  char name[Size + 1]{};
-
-  static constexpr NameBuffer FromCString(const char* str) {
-    NameBuffer result;
-    for (size_t i = 0; i < Size; ++i) result.name[i] = str[i];
-    result.name[Size] = 0;
-    return result;
-  }
-};
-
-template <typename T>
-const char* GetTypename() {
-  static constexpr char kSelfPrefix[] =
-      "const char *cppgc::internal::GetTypename() [T =";
-  static_assert(__builtin_strncmp(__PRETTY_FUNCTION__, kSelfPrefix,
-                                  sizeof(kSelfPrefix) - 1) == 0,
-                "The prefix must match");
-  static constexpr const char* kTypenameStart =
-      __PRETTY_FUNCTION__ + sizeof(kSelfPrefix);
-  static constexpr size_t kTypenameSize =
-      __builtin_strlen(__PRETTY_FUNCTION__) - sizeof(kSelfPrefix) - 1;
-  // NameBuffer is an indirection that is needed to make sure that only a
-  // substring of __PRETTY_FUNCTION__ gets materialized in the binary.
-  static constexpr auto buffer =
-      NameBuffer<kTypenameSize>::FromCString(kTypenameStart);
-  return buffer.name;
-}
-
-#else
-#define CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME 0
-#endif
-
-struct HeapObjectName {
-  const char* value;
-  bool name_was_hidden;
-};
-
-class V8_EXPORT NameTraitBase {
- protected:
-  static HeapObjectName GetNameFromTypeSignature(const char*);
-};
-
-// Trait that specifies how the garbage collector retrieves the name for a
-// given object.
-template <typename T>
-class NameTrait final : public NameTraitBase {
- public:
-  static constexpr bool HasNonHiddenName() {
-#if CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME
-    return true;
-#elif CPPGC_SUPPORTS_OBJECT_NAMES
-    return true;
-#else   // !CPPGC_SUPPORTS_OBJECT_NAMES
-    return std::is_base_of<NameProvider, T>::value;
-#endif  // !CPPGC_SUPPORTS_OBJECT_NAMES
-  }
-
-  static HeapObjectName GetName(const void* obj) {
-    return GetNameFor(static_cast<const T*>(obj));
-  }
-
- private:
-  static HeapObjectName GetNameFor(const NameProvider* name_provider) {
-    return {name_provider->GetHumanReadableName(), false};
-  }
-
-  static HeapObjectName GetNameFor(...) {
-#if CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME
-    return {GetTypename<T>(), false};
-#elif CPPGC_SUPPORTS_OBJECT_NAMES
-
-#if defined(V8_CC_GNU)
-#define PRETTY_FUNCTION_VALUE __PRETTY_FUNCTION__
-#elif defined(V8_CC_MSVC)
-#define PRETTY_FUNCTION_VALUE __FUNCSIG__
-#else
-#define PRETTY_FUNCTION_VALUE nullptr
-#endif
-
-    static const HeapObjectName leaky_name =
-        GetNameFromTypeSignature(PRETTY_FUNCTION_VALUE);
-    return {leaky_name, false};
-
-#undef PRETTY_FUNCTION_VALUE
-
-#else   // !CPPGC_SUPPORTS_OBJECT_NAMES
-    return {NameProvider::kHiddenName, true};
-#endif  // !CPPGC_SUPPORTS_OBJECT_NAMES
-  }
-};
-
-using NameCallback = HeapObjectName (*)(const void*);
-
-}  // namespace internal
-}  // namespace cppgc
-
-#undef CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME
-
-#endif  // INCLUDE_CPPGC_INTERNAL_NAME_TRAIT_H_

package/pods/Headers/include/cppgc/internal/persistent-node.h

@@ -1,216 +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_INTERNAL_PERSISTENT_NODE_H_
-#define INCLUDE_CPPGC_INTERNAL_PERSISTENT_NODE_H_
-
-#include <array>
-#include <memory>
-#include <vector>
-
-#include "cppgc/internal/logging.h"
-#include "cppgc/trace-trait.h"
-#include "v8config.h"  // NOLINT(build/include_directory)
-
-namespace cppgc {
-
-class Visitor;
-
-namespace internal {
-
-class CrossThreadPersistentRegion;
-class FatalOutOfMemoryHandler;
-
-// PersistentNode represents a variant of two states:
-// 1) traceable node with a back pointer to the Persistent object;
-// 2) freelist entry.
-class PersistentNode final {
- public:
-  PersistentNode() = default;
-
-  PersistentNode(const PersistentNode&) = delete;
-  PersistentNode& operator=(const PersistentNode&) = delete;
-
-  void InitializeAsUsedNode(void* owner, TraceCallback trace) {
-    CPPGC_DCHECK(trace);
-    owner_ = owner;
-    trace_ = trace;
-  }
-
-  void InitializeAsFreeNode(PersistentNode* next) {
-    next_ = next;
-    trace_ = nullptr;
-  }
-
-  void UpdateOwner(void* owner) {
-    CPPGC_DCHECK(IsUsed());
-    owner_ = owner;
-  }
-
-  PersistentNode* FreeListNext() const {
-    CPPGC_DCHECK(!IsUsed());
-    return next_;
-  }
-
-  void Trace(Visitor* visitor) const {
-    CPPGC_DCHECK(IsUsed());
-    trace_(visitor, owner_);
-  }
-
-  bool IsUsed() const { return trace_; }
-
-  void* owner() const {
-    CPPGC_DCHECK(IsUsed());
-    return owner_;
-  }
-
- private:
-  // PersistentNode acts as a designated union:
-  // If trace_ != nullptr, owner_ points to the corresponding Persistent handle.
-  // Otherwise, next_ points to the next freed PersistentNode.
-  union {
-    void* owner_ = nullptr;
-    PersistentNode* next_;
-  };
-  TraceCallback trace_ = nullptr;
-};
-
-class V8_EXPORT PersistentRegionBase {
-  using PersistentNodeSlots = std::array<PersistentNode, 256u>;
-
- public:
-  // Clears Persistent fields to avoid stale pointers after heap teardown.
-  ~PersistentRegionBase();
-
-  PersistentRegionBase(const PersistentRegionBase&) = delete;
-  PersistentRegionBase& operator=(const PersistentRegionBase&) = delete;
-
-  void Trace(Visitor*);
-
-  size_t NodesInUse() const;
-
-  void ClearAllUsedNodes();
-
- protected:
-  explicit PersistentRegionBase(const FatalOutOfMemoryHandler& oom_handler);
-
-  PersistentNode* TryAllocateNodeFromFreeList(void* owner,
-                                              TraceCallback trace) {
-    PersistentNode* node = nullptr;
-    if (V8_LIKELY(free_list_head_)) {
-      node = free_list_head_;
-      free_list_head_ = free_list_head_->FreeListNext();
-      CPPGC_DCHECK(!node->IsUsed());
-      node->InitializeAsUsedNode(owner, trace);
-      nodes_in_use_++;
-    }
-    return node;
-  }
-
-  void FreeNode(PersistentNode* node) {
-    CPPGC_DCHECK(node);
-    CPPGC_DCHECK(node->IsUsed());
-    node->InitializeAsFreeNode(free_list_head_);
-    free_list_head_ = node;
-    CPPGC_DCHECK(nodes_in_use_ > 0);
-    nodes_in_use_--;
-  }
-
-  PersistentNode* RefillFreeListAndAllocateNode(void* owner,
-                                                TraceCallback trace);
-
- private:
-  template <typename PersistentBaseClass>
-  void ClearAllUsedNodes();
-
-  void RefillFreeList();
-
-  std::vector<std::unique_ptr<PersistentNodeSlots>> nodes_;
-  PersistentNode* free_list_head_ = nullptr;
-  size_t nodes_in_use_ = 0;
-  const FatalOutOfMemoryHandler& oom_handler_;
-
-  friend class CrossThreadPersistentRegion;
-};
-
-// Variant of PersistentRegionBase that checks whether the allocation and
-// freeing happens only on the thread that created the region.
-class V8_EXPORT PersistentRegion final : public PersistentRegionBase {
- public:
-  explicit PersistentRegion(const FatalOutOfMemoryHandler&);
-  // Clears Persistent fields to avoid stale pointers after heap teardown.
-  ~PersistentRegion() = default;
-
-  PersistentRegion(const PersistentRegion&) = delete;
-  PersistentRegion& operator=(const PersistentRegion&) = delete;
-
-  V8_INLINE PersistentNode* AllocateNode(void* owner, TraceCallback trace) {
-    CPPGC_DCHECK(IsCreationThread());
-    auto* node = TryAllocateNodeFromFreeList(owner, trace);
-    if (V8_LIKELY(node)) return node;
-
-    // Slow path allocation allows for checking thread correspondence.
-    CPPGC_CHECK(IsCreationThread());
-    return RefillFreeListAndAllocateNode(owner, trace);
-  }
-
-  V8_INLINE void FreeNode(PersistentNode* node) {
-    CPPGC_DCHECK(IsCreationThread());
-    PersistentRegionBase::FreeNode(node);
-  }
-
- private:
-  bool IsCreationThread();
-
-  int creation_thread_id_;
-};
-
-// CrossThreadPersistent uses PersistentRegionBase but protects it using this
-// lock when needed.
-class V8_EXPORT PersistentRegionLock final {
- public:
-  PersistentRegionLock();
-  ~PersistentRegionLock();
-
-  static void AssertLocked();
-};
-
-// Variant of PersistentRegionBase that checks whether the PersistentRegionLock
-// is locked.
-class V8_EXPORT CrossThreadPersistentRegion final
-    : protected PersistentRegionBase {
- public:
-  explicit CrossThreadPersistentRegion(const FatalOutOfMemoryHandler&);
-  // Clears Persistent fields to avoid stale pointers after heap teardown.
-  ~CrossThreadPersistentRegion();
-
-  CrossThreadPersistentRegion(const CrossThreadPersistentRegion&) = delete;
-  CrossThreadPersistentRegion& operator=(const CrossThreadPersistentRegion&) =
-      delete;
-
-  V8_INLINE PersistentNode* AllocateNode(void* owner, TraceCallback trace) {
-    PersistentRegionLock::AssertLocked();
-    auto* node = TryAllocateNodeFromFreeList(owner, trace);
-    if (V8_LIKELY(node)) return node;
-
-    return RefillFreeListAndAllocateNode(owner, trace);
-  }
-
-  V8_INLINE void FreeNode(PersistentNode* node) {
-    PersistentRegionLock::AssertLocked();
-    PersistentRegionBase::FreeNode(node);
-  }
-
-  void Trace(Visitor*);
-
-  size_t NodesInUse() const;
-
-  void ClearAllUsedNodes();
-};
-
-}  // namespace internal
-
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_INTERNAL_PERSISTENT_NODE_H_

package/pods/Headers/include/cppgc/internal/pointer-policies.h

@@ -1,186 +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_INTERNAL_POINTER_POLICIES_H_
-#define INCLUDE_CPPGC_INTERNAL_POINTER_POLICIES_H_
-
-#include <cstdint>
-#include <type_traits>
-
-#include "cppgc/internal/write-barrier.h"
-#include "cppgc/sentinel-pointer.h"
-#include "cppgc/source-location.h"
-#include "cppgc/type-traits.h"
-#include "v8config.h"  // NOLINT(build/include_directory)
-
-namespace cppgc {
-namespace internal {
-
-class HeapBase;
-class PersistentRegion;
-class CrossThreadPersistentRegion;
-
-// Tags to distinguish between strong and weak member types.
-class StrongMemberTag;
-class WeakMemberTag;
-class UntracedMemberTag;
-
-struct DijkstraWriteBarrierPolicy {
-  static void InitializingBarrier(const void*, const void*) {
-    // Since in initializing writes the source object is always white, having no
-    // barrier doesn't break the tri-color invariant.
-  }
-  static void AssigningBarrier(const void* slot, const void* value) {
-    WriteBarrier::Params params;
-    switch (WriteBarrier::GetWriteBarrierType(slot, value, params)) {
-      case WriteBarrier::Type::kGenerational:
-        WriteBarrier::GenerationalBarrier(params, slot);
-        break;
-      case WriteBarrier::Type::kMarking:
-        WriteBarrier::DijkstraMarkingBarrier(params, value);
-        break;
-      case WriteBarrier::Type::kNone:
-        break;
-    }
-  }
-};
-
-struct NoWriteBarrierPolicy {
-  static void InitializingBarrier(const void*, const void*) {}
-  static void AssigningBarrier(const void*, const void*) {}
-};
-
-class V8_EXPORT SameThreadEnabledCheckingPolicyBase {
- protected:
-  void CheckPointerImpl(const void* ptr, bool points_to_payload,
-                        bool check_off_heap_assignments);
-
-  const HeapBase* heap_ = nullptr;
-};
-
-template <bool kCheckOffHeapAssignments>
-class V8_EXPORT SameThreadEnabledCheckingPolicy
-    : private SameThreadEnabledCheckingPolicyBase {
- protected:
-  template <typename T>
-  void CheckPointer(const T* ptr) {
-    if (!ptr || (kSentinelPointer == ptr)) return;
-
-    CheckPointersImplTrampoline<T>::Call(this, ptr);
-  }
-
- private:
-  template <typename T, bool = IsCompleteV<T>>
-  struct CheckPointersImplTrampoline {
-    static void Call(SameThreadEnabledCheckingPolicy* policy, const T* ptr) {
-      policy->CheckPointerImpl(ptr, false, kCheckOffHeapAssignments);
-    }
-  };
-
-  template <typename T>
-  struct CheckPointersImplTrampoline<T, true> {
-    static void Call(SameThreadEnabledCheckingPolicy* policy, const T* ptr) {
-      policy->CheckPointerImpl(ptr, IsGarbageCollectedTypeV<T>,
-                               kCheckOffHeapAssignments);
-    }
-  };
-};
-
-class DisabledCheckingPolicy {
- protected:
-  void CheckPointer(const void*) {}
-};
-
-#ifdef DEBUG
-// Off heap members are not connected to object graph and thus cannot ressurect
-// dead objects.
-using DefaultMemberCheckingPolicy =
-    SameThreadEnabledCheckingPolicy<false /* kCheckOffHeapAssignments*/>;
-using DefaultPersistentCheckingPolicy =
-    SameThreadEnabledCheckingPolicy<true /* kCheckOffHeapAssignments*/>;
-#else   // !DEBUG
-using DefaultMemberCheckingPolicy = DisabledCheckingPolicy;
-using DefaultPersistentCheckingPolicy = DisabledCheckingPolicy;
-#endif  // !DEBUG
-// For CT(W)P neither marking information (for value), nor objectstart bitmap
-// (for slot) are guaranteed to be present because there's no synchronization
-// between heaps after marking.
-using DefaultCrossThreadPersistentCheckingPolicy = DisabledCheckingPolicy;
-
-class KeepLocationPolicy {
- public:
-  constexpr const SourceLocation& Location() const { return location_; }
-
- protected:
-  constexpr KeepLocationPolicy() = default;
-  constexpr explicit KeepLocationPolicy(const SourceLocation& location)
-      : location_(location) {}
-
-  // KeepLocationPolicy must not copy underlying source locations.
-  KeepLocationPolicy(const KeepLocationPolicy&) = delete;
-  KeepLocationPolicy& operator=(const KeepLocationPolicy&) = delete;
-
-  // Location of the original moved from object should be preserved.
-  KeepLocationPolicy(KeepLocationPolicy&&) = default;
-  KeepLocationPolicy& operator=(KeepLocationPolicy&&) = default;
-
- private:
-  SourceLocation location_;
-};
-
-class IgnoreLocationPolicy {
- public:
-  constexpr SourceLocation Location() const { return {}; }
-
- protected:
-  constexpr IgnoreLocationPolicy() = default;
-  constexpr explicit IgnoreLocationPolicy(const SourceLocation&) {}
-};
-
-#if CPPGC_SUPPORTS_OBJECT_NAMES
-using DefaultLocationPolicy = KeepLocationPolicy;
-#else
-using DefaultLocationPolicy = IgnoreLocationPolicy;
-#endif
-
-struct StrongPersistentPolicy {
-  using IsStrongPersistent = std::true_type;
-  static V8_EXPORT PersistentRegion& GetPersistentRegion(const void* object);
-};
-
-struct WeakPersistentPolicy {
-  using IsStrongPersistent = std::false_type;
-  static V8_EXPORT PersistentRegion& GetPersistentRegion(const void* object);
-};
-
-struct StrongCrossThreadPersistentPolicy {
-  using IsStrongPersistent = std::true_type;
-  static V8_EXPORT CrossThreadPersistentRegion& GetPersistentRegion(
-      const void* object);
-};
-
-struct WeakCrossThreadPersistentPolicy {
-  using IsStrongPersistent = std::false_type;
-  static V8_EXPORT CrossThreadPersistentRegion& GetPersistentRegion(
-      const void* object);
-};
-
-// Forward declarations setting up the default policies.
-template <typename T, typename WeaknessPolicy,
-          typename LocationPolicy = DefaultLocationPolicy,
-          typename CheckingPolicy = DefaultCrossThreadPersistentCheckingPolicy>
-class BasicCrossThreadPersistent;
-template <typename T, typename WeaknessPolicy,
-          typename LocationPolicy = DefaultLocationPolicy,
-          typename CheckingPolicy = DefaultPersistentCheckingPolicy>
-class BasicPersistent;
-template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
-          typename CheckingPolicy = DefaultMemberCheckingPolicy>
-class BasicMember;
-
-}  // namespace internal
-
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_INTERNAL_POINTER_POLICIES_H_