@shopify/react-native-skia 0.0.135

package/cpp/skia/include/private/SkTemplates.h

@@ -0,0 +1,453 @@
+/*
+ * Copyright 2006 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkTemplates_DEFINED
+#define SkTemplates_DEFINED
+
+#include "include/core/SkTypes.h"
+#include "include/private/SkMalloc.h"
+#include "include/private/SkTLogic.h"
+
+#include <string.h>
+#include <array>
+#include <cstddef>
+#include <memory>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+/** \file SkTemplates.h
+
+    This file contains light-weight template classes for type-safe and exception-safe
+    resource management.
+*/
+
+/**
+ *  Marks a local variable as known to be unused (to avoid warnings).
+ *  Note that this does *not* prevent the local variable from being optimized away.
+ */
+template<typename T> inline void sk_ignore_unused_variable(const T&) { }
+
+/**
+ *  Returns a pointer to a D which comes immediately after S[count].
+ */
+template <typename D, typename S> inline D* SkTAfter(S* ptr, size_t count = 1) {
+    return reinterpret_cast<D*>(ptr + count);
+}
+
+/**
+ *  Returns a pointer to a D which comes byteOffset bytes after S.
+ */
+template <typename D, typename S> inline D* SkTAddOffset(S* ptr, ptrdiff_t byteOffset) {
+    // The intermediate char* has the same cv-ness as D as this produces better error messages.
+    // This relies on the fact that reinterpret_cast can add constness, but cannot remove it.
+    return reinterpret_cast<D*>(reinterpret_cast<sknonstd::same_cv_t<char, D>*>(ptr) + byteOffset);
+}
+
+// TODO: when C++17 the language is available, use template <auto P>
+template <typename T, T* P> struct SkFunctionWrapper {
+    template <typename... Args>
+    auto operator()(Args&&... args) const -> decltype(P(std::forward<Args>(args)...)) {
+        return P(std::forward<Args>(args)...);
+    }
+};
+
+/** \class SkAutoTCallVProc
+
+    Call a function when this goes out of scope. The template uses two
+    parameters, the object, and a function that is to be called in the destructor.
+    If release() is called, the object reference is set to null. If the object
+    reference is null when the destructor is called, we do not call the
+    function.
+*/
+template <typename T, void (*P)(T*)> class SkAutoTCallVProc
+    : public std::unique_ptr<T, SkFunctionWrapper<std::remove_pointer_t<decltype(P)>, P>> {
+    using inherited = std::unique_ptr<T, SkFunctionWrapper<std::remove_pointer_t<decltype(P)>, P>>;
+public:
+    using inherited::inherited;
+    SkAutoTCallVProc(const SkAutoTCallVProc&) = delete;
+    SkAutoTCallVProc(SkAutoTCallVProc&& that) : inherited(std::move(that)) {}
+
+    operator T*() const { return this->get(); }
+};
+
+/** Allocate an array of T elements, and free the array in the destructor
+ */
+template <typename T> class SkAutoTArray  {
+public:
+    SkAutoTArray() {}
+    /** Allocate count number of T elements
+     */
+    explicit SkAutoTArray(int count) {
+        SkASSERT(count >= 0);
+        if (count) {
+            fArray.reset(new T[count]);
+        }
+        SkDEBUGCODE(fCount = count;)
+    }
+
+    SkAutoTArray(SkAutoTArray&& other) : fArray(std::move(other.fArray)) {
+        SkDEBUGCODE(fCount = other.fCount; other.fCount = 0;)
+    }
+    SkAutoTArray& operator=(SkAutoTArray&& other) {
+        if (this != &other) {
+            fArray = std::move(other.fArray);
+            SkDEBUGCODE(fCount = other.fCount; other.fCount = 0;)
+        }
+        return *this;
+    }
+
+    /** Reallocates given a new count. Reallocation occurs even if new count equals old count.
+     */
+    void reset(int count = 0) { *this = SkAutoTArray(count); }
+
+    /** Return the array of T elements. Will be NULL if count == 0
+     */
+    T* get() const { return fArray.get(); }
+
+    /** Return the nth element in the array
+     */
+    T&  operator[](int index) const {
+        SkASSERT((unsigned)index < (unsigned)fCount);
+        return fArray[index];
+    }
+
+    /** Aliases matching other types, like std::vector. */
+    const T* data() const { return fArray.get(); }
+    T* data() { return fArray.get(); }
+
+private:
+    std::unique_ptr<T[]> fArray;
+    SkDEBUGCODE(int fCount = 0;)
+};
+
+/** Wraps SkAutoTArray, with room for kCountRequested elements preallocated.
+ */
+template <int kCountRequested, typename T> class SkAutoSTArray {
+public:
+    SkAutoSTArray(SkAutoSTArray&&) = delete;
+    SkAutoSTArray(const SkAutoSTArray&) = delete;
+    SkAutoSTArray& operator=(SkAutoSTArray&&) = delete;
+    SkAutoSTArray& operator=(const SkAutoSTArray&) = delete;
+
+    /** Initialize with no objects */
+    SkAutoSTArray() {
+        fArray = nullptr;
+        fCount = 0;
+    }
+
+    /** Allocate count number of T elements
+     */
+    SkAutoSTArray(int count) {
+        fArray = nullptr;
+        fCount = 0;
+        this->reset(count);
+    }
+
+    ~SkAutoSTArray() {
+        this->reset(0);
+    }
+
+    /** Destroys previous objects in the array and default constructs count number of objects */
+    void reset(int count) {
+        T* start = fArray;
+        T* iter = start + fCount;
+        while (iter > start) {
+            (--iter)->~T();
+        }
+
+        SkASSERT(count >= 0);
+        if (fCount != count) {
+            if (fCount > kCount) {
+                // 'fArray' was allocated last time so free it now
+                SkASSERT((T*) fStorage != fArray);
+                sk_free(fArray);
+            }
+
+            if (count > kCount) {
+                fArray = (T*) sk_malloc_throw(count, sizeof(T));
+            } else if (count > 0) {
+                fArray = (T*) fStorage;
+            } else {
+                fArray = nullptr;
+            }
+
+            fCount = count;
+        }
+
+        iter = fArray;
+        T* stop = fArray + count;
+        while (iter < stop) {
+            new (iter++) T;
+        }
+    }
+
+    /** Return the number of T elements in the array
+     */
+    int count() const { return fCount; }
+
+    /** Return the array of T elements. Will be NULL if count == 0
+     */
+    T* get() const { return fArray; }
+
+    T* begin() { return fArray; }
+
+    const T* begin() const { return fArray; }
+
+    T* end() { return fArray + fCount; }
+
+    const T* end() const { return fArray + fCount; }
+
+    /** Return the nth element in the array
+     */
+    T&  operator[](int index) const {
+        SkASSERT(index < fCount);
+        return fArray[index];
+    }
+
+    /** Aliases matching other types, like std::vector. */
+    const T* data() const { return fArray; }
+    T* data() { return fArray; }
+    size_t size() const { return fCount; }
+
+private:
+#if defined(SK_BUILD_FOR_GOOGLE3)
+    // Stack frame size is limited for SK_BUILD_FOR_GOOGLE3. 4k is less than the actual max, but some functions
+    // have multiple large stack allocations.
+    static const int kMaxBytes = 4 * 1024;
+    static const int kCount = kCountRequested * sizeof(T) > kMaxBytes
+        ? kMaxBytes / sizeof(T)
+        : kCountRequested;
+#else
+    static const int kCount = kCountRequested;
+#endif
+
+    int     fCount;
+    T*      fArray;
+    // since we come right after fArray, fStorage should be properly aligned
+    char    fStorage[kCount * sizeof(T)];
+};
+
+/** Manages an array of T elements, freeing the array in the destructor.
+ *  Does NOT call any constructors/destructors on T (T must be POD).
+ */
+template <typename T,
+          typename = std::enable_if_t<std::is_trivially_default_constructible<T>::value &&
+                                      std::is_trivially_destructible<T>::value>>
+class SkAutoTMalloc  {
+public:
+    /** Takes ownership of the ptr. The ptr must be a value which can be passed to sk_free. */
+    explicit SkAutoTMalloc(T* ptr = nullptr) : fPtr(ptr) {}
+
+    /** Allocates space for 'count' Ts. */
+    explicit SkAutoTMalloc(size_t count)
+        : fPtr(count ? (T*)sk_malloc_throw(count, sizeof(T)) : nullptr) {}
+
+    SkAutoTMalloc(SkAutoTMalloc&&) = default;
+    SkAutoTMalloc& operator=(SkAutoTMalloc&&) = default;
+
+    /** Resize the memory area pointed to by the current ptr preserving contents. */
+    void realloc(size_t count) {
+        fPtr.reset(count ? (T*)sk_realloc_throw(fPtr.release(), count * sizeof(T)) : nullptr);
+    }
+
+    /** Resize the memory area pointed to by the current ptr without preserving contents. */
+    T* reset(size_t count = 0) {
+        fPtr.reset(count ? (T*)sk_malloc_throw(count, sizeof(T)) : nullptr);
+        return this->get();
+    }
+
+    T* get() const { return fPtr.get(); }
+
+    operator T*() { return fPtr.get(); }
+
+    operator const T*() const { return fPtr.get(); }
+
+    T& operator[](int index) { return fPtr.get()[index]; }
+
+    const T& operator[](int index) const { return fPtr.get()[index]; }
+
+    /** Aliases matching other types, like std::vector. */
+    const T* data() const { return fPtr.get(); }
+    T* data() { return fPtr.get(); }
+
+    /**
+     *  Transfer ownership of the ptr to the caller, setting the internal
+     *  pointer to NULL. Note that this differs from get(), which also returns
+     *  the pointer, but it does not transfer ownership.
+     */
+    T* release() { return fPtr.release(); }
+
+private:
+    std::unique_ptr<T, SkFunctionWrapper<void(void*), sk_free>> fPtr;
+};
+
+template <size_t kCountRequested,
+          typename T,
+          typename = std::enable_if_t<std::is_trivially_default_constructible<T>::value &&
+                                      std::is_trivially_destructible<T>::value>>
+class SkAutoSTMalloc {
+public:
+    SkAutoSTMalloc() : fPtr(fTStorage) {}
+
+    SkAutoSTMalloc(size_t count) {
+        if (count > kCount) {
+            fPtr = (T*)sk_malloc_throw(count, sizeof(T));
+        } else if (count) {
+            fPtr = fTStorage;
+        } else {
+            fPtr = nullptr;
+        }
+    }
+
+    SkAutoSTMalloc(SkAutoSTMalloc&&) = delete;
+    SkAutoSTMalloc(const SkAutoSTMalloc&) = delete;
+    SkAutoSTMalloc& operator=(SkAutoSTMalloc&&) = delete;
+    SkAutoSTMalloc& operator=(const SkAutoSTMalloc&) = delete;
+
+    ~SkAutoSTMalloc() {
+        if (fPtr != fTStorage) {
+            sk_free(fPtr);
+        }
+    }
+
+    // doesn't preserve contents
+    T* reset(size_t count) {
+        if (fPtr != fTStorage) {
+            sk_free(fPtr);
+        }
+        if (count > kCount) {
+            fPtr = (T*)sk_malloc_throw(count, sizeof(T));
+        } else if (count) {
+            fPtr = fTStorage;
+        } else {
+            fPtr = nullptr;
+        }
+        return fPtr;
+    }
+
+    T* get() const { return fPtr; }
+
+    operator T*() {
+        return fPtr;
+    }
+
+    operator const T*() const {
+        return fPtr;
+    }
+
+    T& operator[](int index) {
+        return fPtr[index];
+    }
+
+    const T& operator[](int index) const {
+        return fPtr[index];
+    }
+
+    /** Aliases matching other types, like std::vector. */
+    const T* data() const { return fPtr; }
+    T* data() { return fPtr; }
+
+    // Reallocs the array, can be used to shrink the allocation.  Makes no attempt to be intelligent
+    void realloc(size_t count) {
+        if (count > kCount) {
+            if (fPtr == fTStorage) {
+                fPtr = (T*)sk_malloc_throw(count, sizeof(T));
+                memcpy((void*)fPtr, fTStorage, kCount * sizeof(T));
+            } else {
+                fPtr = (T*)sk_realloc_throw(fPtr, count, sizeof(T));
+            }
+        } else if (count) {
+            if (fPtr != fTStorage) {
+                fPtr = (T*)sk_realloc_throw(fPtr, count, sizeof(T));
+            }
+        } else {
+            this->reset(0);
+        }
+    }
+
+private:
+    // Since we use uint32_t storage, we might be able to get more elements for free.
+    static const size_t kCountWithPadding = SkAlign4(kCountRequested*sizeof(T)) / sizeof(T);
+#if defined(SK_BUILD_FOR_GOOGLE3)
+    // Stack frame size is limited for SK_BUILD_FOR_GOOGLE3. 4k is less than the actual max, but some functions
+    // have multiple large stack allocations.
+    static const size_t kMaxBytes = 4 * 1024;
+    static const size_t kCount = kCountRequested * sizeof(T) > kMaxBytes
+        ? kMaxBytes / sizeof(T)
+        : kCountWithPadding;
+#else
+    static const size_t kCount = kCountWithPadding;
+#endif
+
+    T*          fPtr;
+    union {
+        uint32_t    fStorage32[SkAlign4(kCount*sizeof(T)) >> 2];
+        T           fTStorage[1];   // do NOT want to invoke T::T()
+    };
+};
+
+//////////////////////////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Pass the object and the storage that was offered during SkInPlaceNewCheck, and this will
+ *  safely destroy (and free if it was dynamically allocated) the object.
+ */
+template <typename T> void SkInPlaceDeleteCheck(T* obj, void* storage) {
+    if (storage == obj) {
+        obj->~T();
+    } else {
+        delete obj;
+    }
+}
+
+/**
+ *  Allocates T, using storage if it is large enough, and allocating on the heap (via new) if
+ *  storage is not large enough.
+ *
+ *      obj = SkInPlaceNewCheck<Type>(storage, size);
+ *      ...
+ *      SkInPlaceDeleteCheck(obj, storage);
+ */
+template<typename T, typename... Args>
+T* SkInPlaceNewCheck(void* storage, size_t size, Args&&... args) {
+    return (sizeof(T) <= size) ? new (storage) T(std::forward<Args>(args)...)
+                               : new T(std::forward<Args>(args)...);
+}
+
+template <int N, typename T> class SkAlignedSTStorage {
+public:
+    SkAlignedSTStorage() {}
+    SkAlignedSTStorage(SkAlignedSTStorage&&) = delete;
+    SkAlignedSTStorage(const SkAlignedSTStorage&) = delete;
+    SkAlignedSTStorage& operator=(SkAlignedSTStorage&&) = delete;
+    SkAlignedSTStorage& operator=(const SkAlignedSTStorage&) = delete;
+
+    /**
+     * Returns void* because this object does not initialize the
+     * memory. Use placement new for types that require a constructor.
+     */
+    void* get() { return fStorage; }
+    const void* get() const { return fStorage; }
+private:
+    alignas(T) char fStorage[sizeof(T)*N];
+};
+
+using SkAutoFree = std::unique_ptr<void, SkFunctionWrapper<void(void*), sk_free>>;
+
+template<typename C, std::size_t... Is>
+constexpr auto SkMakeArrayFromIndexSequence(C c, std::index_sequence<Is...> is)
+-> std::array<decltype(c(std::declval<typename decltype(is)::value_type>())), sizeof...(Is)> {
+    return {{ c(Is)... }};
+}
+
+template<size_t N, typename C> constexpr auto SkMakeArray(C c)
+-> std::array<decltype(c(std::declval<typename std::index_sequence<N>::value_type>())), N> {
+    return SkMakeArrayFromIndexSequence(c, std::make_index_sequence<N>{});
+}
+
+#endif

package/cpp/skia/include/private/SkThreadAnnotations.h

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2019 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkThreadAnnotations_DEFINED
+#define SkThreadAnnotations_DEFINED
+
+// The bulk of this code is cribbed from:
+// http://clang.llvm.org/docs/ThreadSafetyAnalysis.html
+
+#if defined(__clang__) && (!defined(SWIG))
+#define SK_THREAD_ANNOTATION_ATTRIBUTE(x)   __attribute__((x))
+#else
+#define SK_THREAD_ANNOTATION_ATTRIBUTE(x)   // no-op
+#endif
+
+#define SK_CAPABILITY(x) \
+  SK_THREAD_ANNOTATION_ATTRIBUTE(capability(x))
+
+#define SK_SCOPED_CAPABILITY \
+  SK_THREAD_ANNOTATION_ATTRIBUTE(scoped_lockable)
+
+#define SK_GUARDED_BY(x) \
+  SK_THREAD_ANNOTATION_ATTRIBUTE(guarded_by(x))
+
+#define SK_PT_GUARDED_BY(x) \
+  SK_THREAD_ANNOTATION_ATTRIBUTE(pt_guarded_by(x))
+
+#define SK_ACQUIRED_BEFORE(...) \
+  SK_THREAD_ANNOTATION_ATTRIBUTE(acquired_before(__VA_ARGS__))
+
+#define SK_ACQUIRED_AFTER(...) \
+  SK_THREAD_ANNOTATION_ATTRIBUTE(acquired_after(__VA_ARGS__))
+
+#define SK_REQUIRES(...) \
+  SK_THREAD_ANNOTATION_ATTRIBUTE(requires_capability(__VA_ARGS__))
+
+#define SK_REQUIRES_SHARED(...) \
+  SK_THREAD_ANNOTATION_ATTRIBUTE(requires_shared_capability(__VA_ARGS__))
+
+#define SK_ACQUIRE(...) \
+  SK_THREAD_ANNOTATION_ATTRIBUTE(acquire_capability(__VA_ARGS__))
+
+#define SK_ACQUIRE_SHARED(...) \
+  SK_THREAD_ANNOTATION_ATTRIBUTE(acquire_shared_capability(__VA_ARGS__))
+
+// Would be SK_RELEASE, but that is already in use as SK_DEBUG vs. SK_RELEASE.
+#define SK_RELEASE_CAPABILITY(...) \
+  SK_THREAD_ANNOTATION_ATTRIBUTE(release_capability(__VA_ARGS__))
+
+// For symmetry with SK_RELEASE_CAPABILITY.
+#define SK_RELEASE_SHARED_CAPABILITY(...) \
+  SK_THREAD_ANNOTATION_ATTRIBUTE(release_shared_capability(__VA_ARGS__))
+
+#define SK_TRY_ACQUIRE(...) \
+  SK_THREAD_ANNOTATION_ATTRIBUTE(try_acquire_capability(__VA_ARGS__))
+
+#define SK_TRY_ACQUIRE_SHARED(...) \
+  SK_THREAD_ANNOTATION_ATTRIBUTE(try_acquire_shared_capability(__VA_ARGS__))
+
+#define SK_EXCLUDES(...) \
+  SK_THREAD_ANNOTATION_ATTRIBUTE(locks_excluded(__VA_ARGS__))
+
+#define SK_ASSERT_CAPABILITY(x) \
+  SK_THREAD_ANNOTATION_ATTRIBUTE(assert_capability(x))
+
+#define SK_ASSERT_SHARED_CAPABILITY(x) \
+  SK_THREAD_ANNOTATION_ATTRIBUTE(assert_shared_capability(x))
+
+#define SK_RETURN_CAPABILITY(x) \
+  SK_THREAD_ANNOTATION_ATTRIBUTE(lock_returned(x))
+
+#define SK_NO_THREAD_SAFETY_ANALYSIS \
+  SK_THREAD_ANNOTATION_ATTRIBUTE(no_thread_safety_analysis)
+
+#if defined(SK_BUILD_FOR_GOOGLE3) && !defined(SK_BUILD_FOR_WASM_IN_GOOGLE3)
+    extern "C" {
+        void __google_cxa_guard_acquire_begin(void);
+        void __google_cxa_guard_acquire_end  (void);
+    }
+    #define SK_POTENTIALLY_BLOCKING_REGION_BEGIN __google_cxa_guard_acquire_begin()
+    #define SK_POTENTIALLY_BLOCKING_REGION_END   __google_cxa_guard_acquire_end()
+#else
+    #define SK_POTENTIALLY_BLOCKING_REGION_BEGIN
+    #define SK_POTENTIALLY_BLOCKING_REGION_END
+#endif
+
+#endif  // SkThreadAnnotations_DEFINED

package/cpp/skia/include/private/SkThreadID.h

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkThreadID_DEFINED
+#define SkThreadID_DEFINED
+
+#include "include/core/SkTypes.h"
+
+typedef int64_t SkThreadID;
+
+// SkMutex.h uses SkGetThredID in debug only code.
+SkDEBUGCODE(SK_SPI) SkThreadID SkGetThreadID();
+
+const SkThreadID kIllegalThreadID = 0;
+
+#endif  // SkThreadID_DEFINED

package/cpp/skia/include/private/SkTo.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkTo_DEFINED
+#define SkTo_DEFINED
+
+#include "include/core/SkTypes.h"
+#include "include/private/SkTFitsIn.h"
+
+template <typename D, typename S> constexpr D SkTo(S s) {
+    return SkASSERT(SkTFitsIn<D>(s)),
+           static_cast<D>(s);
+}
+
+template <typename S> constexpr int8_t   SkToS8(S x)    { return SkTo<int8_t>(x);   }
+template <typename S> constexpr uint8_t  SkToU8(S x)    { return SkTo<uint8_t>(x);  }
+template <typename S> constexpr int16_t  SkToS16(S x)   { return SkTo<int16_t>(x);  }
+template <typename S> constexpr uint16_t SkToU16(S x)   { return SkTo<uint16_t>(x); }
+template <typename S> constexpr int32_t  SkToS32(S x)   { return SkTo<int32_t>(x);  }
+template <typename S> constexpr uint32_t SkToU32(S x)   { return SkTo<uint32_t>(x); }
+template <typename S> constexpr int      SkToInt(S x)   { return SkTo<int>(x);      }
+template <typename S> constexpr unsigned SkToUInt(S x)  { return SkTo<unsigned>(x); }
+template <typename S> constexpr size_t   SkToSizeT(S x) { return SkTo<size_t>(x);   }
+
+#endif  // SkTo_DEFINED

package/cpp/skia/include/private/SkUniquePaintParamsID.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkUniquePaintParamsID_DEFINED
+#define SkUniquePaintParamsID_DEFINED
+
+#include "include/core/SkTypes.h"
+
+// This class boils down to a unique uint that can be used instead of a variable length
+// key derived from a PaintParams.
+class SkUniquePaintParamsID {
+public:
+    explicit SkUniquePaintParamsID(uint32_t id) : fID(id) {
+        SkASSERT(id != SK_InvalidUniqueID);
+    }
+
+    static SkUniquePaintParamsID InvalidID() { return SkUniquePaintParamsID(); }
+
+    SkUniquePaintParamsID() : fID(SK_InvalidUniqueID) {}
+
+    bool operator==(const SkUniquePaintParamsID &that) const { return fID == that.fID; }
+    bool operator!=(const SkUniquePaintParamsID &that) const { return !(*this == that); }
+
+    bool isValid() const { return fID != SK_InvalidUniqueID; }
+    uint32_t asUInt() const { return fID; }
+
+private:
+    uint32_t fID;
+};
+
+#endif // SkUniquePaintParamsID_DEFINED