@shopify/react-native-skia 0.1.192 → 0.1.193

package/cpp/skia/include/private/{SkTDArray.h → base/SkTDArray.h}

@@ -8,21 +8,18 @@
 #ifndef SkTDArray_DEFINED
 #define SkTDArray_DEFINED
 
-#include "include/core/SkTypes.h"
-#include "include/private/SkMalloc.h"
-#include "include/private/SkTo.h"
+#include "include/private/base/SkAPI.h"
+#include "include/private/base/SkAssert.h"
+#include "include/private/base/SkTo.h"
 
 #include <algorithm>
 #include <cstddef>
-#include <climits>
 #include <initializer_list>
-#include <tuple>
-#include <utility>
 
 class SK_SPI SkTDStorage {
 public:
     explicit SkTDStorage(int sizeOfT);
-    SkTDStorage(const void* src, int count, int sizeOfT);
+    SkTDStorage(const void* src, int size, int sizeOfT);
 
     // Copy
     SkTDStorage(const SkTDStorage& that);
@@ -38,15 +35,15 @@ public:
     void swap(SkTDStorage& that);
 
     // Size routines
-    bool empty() const { return fCount == 0; }
-    void clear() { fCount = 0; }
-    int size() const { return fCount; }
-    void resize(int newCount);
-    size_t size_bytes() const { return this->bytes(fCount); }
+    bool empty() const { return fSize == 0; }
+    void clear() { fSize = 0; }
+    int size() const { return fSize; }
+    void resize(int newSize);
+    size_t size_bytes() const { return this->bytes(fSize); }
 
     // Capacity routines
-    int capacity() const { return fReserve; }
-    void reserve(int newReserve);
+    int capacity() const { return fCapacity; }
+    void reserve(int newCapacity);
     void shrink_to_fit();
 
     void* data() { return fStorage; }
@@ -68,8 +65,8 @@ public:
     void* insert(int index, int count, const void* src);
 
     void pop_back() {
-        SkASSERT(fCount > 0);
-        fCount--;
+        SkASSERT(fSize > 0);
+        fSize--;
     }
 
     friend bool operator==(const SkTDStorage& a, const SkTDStorage& b);
@@ -81,7 +78,7 @@ private:
     size_t bytes(int n) const { return SkToSizeT(n * fSizeOfT); }
     void* address(int n) { return fStorage + this->bytes(n); }
 
-    // Adds delta to fCount. Crash if outside [0, INT_MAX]
+    // Adds delta to fSize. Crash if outside [0, INT_MAX]
     int calculateSizeOrDie(int delta);
 
     // Move the tail of the array defined by the indexes tailStart and tailEnd to dstIndex. The
@@ -93,8 +90,8 @@ private:
 
     const int fSizeOfT;
     std::byte* fStorage{nullptr};
-    int fReserve{0};  // size of the allocation in fArray (#elements)
-    int fCount{0};    // logical number of elements (fCount <= fReserve)
+    int fCapacity{0};  // size of the allocation in fArray (#elements)
+    int fSize{0};    // logical number of elements (fSize <= fCapacity)
 };
 
 static inline void swap(SkTDStorage& a, SkTDStorage& b) {
@@ -188,7 +185,7 @@ public:
         fStorage.resize(count);
     }
 
-    void reserve(size_t n) {
+    void reserve(int n) {
         fStorage.reserve(n);
     }
 
@@ -219,18 +216,6 @@ public:
         fStorage.removeShuffle(index);
     }
 
-    int find(const T& elem) const {
-        const T* iter = this->begin();
-        const T* stop = this->end();
-
-        for (; iter < stop; iter++) {
-            if (*iter == elem) {
-                return SkToInt(iter - this->begin());
-            }
-        }
-        return -1;
-    }
-
     // routines to treat the array like a stack
     void push_back(const T& v) {
         this->append();
@@ -238,28 +223,6 @@ public:
     }
     void pop_back() { fStorage.pop_back(); }
 
-    void deleteAll() {
-        for (T p : *this) {
-            delete p;
-        }
-        this->reset();
-    }
-
-    void freeAll() {
-        for (T p : *this) {
-            sk_free(p);
-        }
-
-        this->reset();
-    }
-
-    void unrefAll() {
-        for (T p : *this) {
-            p->unref();
-        }
-        this->reset();
-    }
-
     void shrink_to_fit() {
         fStorage.shrink_to_fit();
     }

package/cpp/skia/include/private/{SkTFitsIn.h → base/SkTFitsIn.h}

@@ -8,8 +8,10 @@
 #ifndef SkTFitsIn_DEFINED
 #define SkTFitsIn_DEFINED
 
+#include "include/private/base/SkDebug.h"
+
+#include <cstdint>
 #include <limits>
-#include <stdint.h>
 #include <type_traits>
 
 /**
@@ -71,28 +73,32 @@ static constexpr inline
 typename std::enable_if<(std::is_integral<S>::value || std::is_enum<S>::value) &&
                         (std::is_integral<D>::value || std::is_enum<D>::value), bool>::type
 /*bool*/ SkTFitsIn(S src) {
+    // Ensure that is_signed and is_unsigned are passed the arithmetic underlyng types of enums.
+    using Sa = typename sk_strip_enum<S>::type;
+    using Da = typename sk_strip_enum<D>::type;
+
     // SkTFitsIn() is used in public headers, so needs to be written targeting at most C++11.
     return
 
     // E.g. (int8_t)(uint8_t) int8_t(-1) == -1, but the uint8_t == 255, not -1.
-    (std::is_signed<S>::value && std::is_unsigned<D>::value && sizeof(S) <= sizeof(D)) ?
+    (std::is_signed<Sa>::value && std::is_unsigned<Da>::value && sizeof(Sa) <= sizeof(Da)) ?
         (S)0 <= src :
 
     // E.g. (uint8_t)(int8_t) uint8_t(255) == 255, but the int8_t == -1.
-    (std::is_signed<D>::value && std::is_unsigned<S>::value && sizeof(D) <= sizeof(S)) ?
-        src <= (S)std::numeric_limits<typename sk_strip_enum<D>::type>::max() :
+    (std::is_signed<Da>::value && std::is_unsigned<Sa>::value && sizeof(Da) <= sizeof(Sa)) ?
+        src <= (S)std::numeric_limits<Da>::max() :
 
 #if !defined(SK_DEBUG) && !defined(__MSVC_RUNTIME_CHECKS )
     // Correct (simple) version. This trips up MSVC's /RTCc run-time checking.
     (S)(D)src == src;
 #else
     // More complex version that's safe with /RTCc. Used in all debug builds, for coverage.
-    (std::is_signed<S>::value) ?
-        (intmax_t)src >= (intmax_t)std::numeric_limits<typename sk_strip_enum<D>::type>::min() &&
-        (intmax_t)src <= (intmax_t)std::numeric_limits<typename sk_strip_enum<D>::type>::max() :
+    (std::is_signed<Sa>::value) ?
+        (intmax_t)src >= (intmax_t)std::numeric_limits<Da>::min() &&
+        (intmax_t)src <= (intmax_t)std::numeric_limits<Da>::max() :
 
     // std::is_unsigned<S> ?
-        (uintmax_t)src <= (uintmax_t)std::numeric_limits<typename sk_strip_enum<D>::type>::max();
+        (uintmax_t)src <= (uintmax_t)std::numeric_limits<Da>::max();
 #endif
 }
 

package/cpp/skia/include/private/{SkTLogic.h → base/SkTLogic.h}

@@ -14,7 +14,7 @@
 
 #include <iterator>
 #include <type_traits>
-#include "include/private/SkTo.h"
+#include "include/private/base/SkTo.h"
 
 // The sknonstd namespace contains things we would like to be proposed and feel std-ish.
 namespace sknonstd {

package/cpp/skia/include/private/{SkTemplates.h → base/SkTemplates.h}

@@ -8,18 +8,21 @@
 #ifndef SkTemplates_DEFINED
 #define SkTemplates_DEFINED
 
-#include "include/core/SkTypes.h"
-#include "include/private/SkMalloc.h"
-#include "include/private/SkTLogic.h"
+#include "include/private/base/SkAlign.h"
+#include "include/private/base/SkAssert.h"
+#include "include/private/base/SkDebug.h"
+#include "include/private/base/SkMalloc.h"
+#include "include/private/base/SkTLogic.h"
 
-#include <string.h>
 #include <array>
 #include <cstddef>
+#include <cstdint>
+#include <cstring>
 #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
@@ -32,6 +35,17 @@
  */
 template<typename T> inline void sk_ignore_unused_variable(const T&) { }
 
+/**
+ * This is a general purpose absolute-value function.
+ * See SkAbs32 in (SkSafe32.h) for a 32-bit int specific version that asserts.
+ */
+template <typename T> static inline T SkTAbs(T value) {
+    if (value < 0) {
+        value = -value;
+    }
+    return value;
+}
+
 /**
  *  Returns a pointer to a D which comes immediately after S[count].
  */
@@ -48,14 +62,16 @@ template <typename D, typename S> inline D* SkTAddOffset(S* ptr, ptrdiff_t byteO
     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 T, T* P> struct SkOverloadedFunctionObject {
     template <typename... Args>
     auto operator()(Args&&... args) const -> decltype(P(std::forward<Args>(args)...)) {
         return P(std::forward<Args>(args)...);
     }
 };
 
+template <auto F> using SkFunctionObject =
+    SkOverloadedFunctionObject<std::remove_pointer_t<decltype(F)>, F>;
+
 /** \class SkAutoTCallVProc
 
     Call a function when this goes out of scope. The template uses two
@@ -65,8 +81,8 @@ template <typename T, T* P> struct SkFunctionWrapper {
     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 std::unique_ptr<T, SkFunctionObject<P>> {
+    using inherited = std::unique_ptr<T, SkFunctionObject<P>>;
 public:
     using inherited::inherited;
     SkAutoTCallVProc(const SkAutoTCallVProc&) = delete;
@@ -75,14 +91,16 @@ public:
     operator T*() const { return this->get(); }
 };
 
+
+namespace skia_private {
 /** Allocate an array of T elements, and free the array in the destructor
  */
-template <typename T> class SkAutoTArray  {
+template <typename T> class AutoTArray  {
 public:
-    SkAutoTArray() {}
+    AutoTArray() {}
     /** Allocate count number of T elements
      */
-    explicit SkAutoTArray(int count) {
+    explicit AutoTArray(int count) {
         SkASSERT(count >= 0);
         if (count) {
             fArray.reset(new T[count]);
@@ -90,10 +108,10 @@ public:
         SkDEBUGCODE(fCount = count;)
     }
 
-    SkAutoTArray(SkAutoTArray&& other) : fArray(std::move(other.fArray)) {
+    AutoTArray(AutoTArray&& other) : fArray(std::move(other.fArray)) {
         SkDEBUGCODE(fCount = other.fCount; other.fCount = 0;)
     }
-    SkAutoTArray& operator=(SkAutoTArray&& other) {
+    AutoTArray& operator=(AutoTArray&& other) {
         if (this != &other) {
             fArray = std::move(other.fArray);
             SkDEBUGCODE(fCount = other.fCount; other.fCount = 0;)
@@ -103,7 +121,7 @@ public:
 
     /** Reallocates given a new count. Reallocation occurs even if new count equals old count.
      */
-    void reset(int count = 0) { *this = SkAutoTArray(count); }
+    void reset(int count = 0) { *this = AutoTArray(count); }
 
     /** Return the array of T elements. Will be NULL if count == 0
      */
@@ -125,30 +143,30 @@ private:
     SkDEBUGCODE(int fCount = 0;)
 };
 
-/** Wraps SkAutoTArray, with room for kCountRequested elements preallocated.
+/** Wraps AutoTArray, with room for kCountRequested elements preallocated.
  */
-template <int kCountRequested, typename T> class SkAutoSTArray {
+template <int kCountRequested, typename T> class AutoSTArray {
 public:
-    SkAutoSTArray(SkAutoSTArray&&) = delete;
-    SkAutoSTArray(const SkAutoSTArray&) = delete;
-    SkAutoSTArray& operator=(SkAutoSTArray&&) = delete;
-    SkAutoSTArray& operator=(const SkAutoSTArray&) = delete;
+    AutoSTArray(AutoSTArray&&) = delete;
+    AutoSTArray(const AutoSTArray&) = delete;
+    AutoSTArray& operator=(AutoSTArray&&) = delete;
+    AutoSTArray& operator=(const AutoSTArray&) = delete;
 
     /** Initialize with no objects */
-    SkAutoSTArray() {
+    AutoSTArray() {
         fArray = nullptr;
         fCount = 0;
     }
 
     /** Allocate count number of T elements
      */
-    SkAutoSTArray(int count) {
+    AutoSTArray(int count) {
         fArray = nullptr;
         fCount = 0;
         this->reset(count);
     }
 
-    ~SkAutoSTArray() {
+    ~AutoSTArray() {
         this->reset(0);
     }
 
@@ -216,8 +234,8 @@ public:
 
 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.
+    // 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)
@@ -226,10 +244,9 @@ private:
     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)];
+    int fCount;
+    T* fArray;
+    alignas(T) char fStorage[kCount * sizeof(T)];
 };
 
 /** Manages an array of T elements, freeing the array in the destructor.
@@ -238,17 +255,17 @@ private:
 template <typename T,
           typename = std::enable_if_t<std::is_trivially_default_constructible<T>::value &&
                                       std::is_trivially_destructible<T>::value>>
-class SkAutoTMalloc  {
+class AutoTMalloc  {
 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) {}
+    explicit AutoTMalloc(T* ptr = nullptr) : fPtr(ptr) {}
 
     /** Allocates space for 'count' Ts. */
-    explicit SkAutoTMalloc(size_t count)
+    explicit AutoTMalloc(size_t count)
         : fPtr(count ? (T*)sk_malloc_throw(count, sizeof(T)) : nullptr) {}
 
-    SkAutoTMalloc(SkAutoTMalloc&&) = default;
-    SkAutoTMalloc& operator=(SkAutoTMalloc&&) = default;
+    AutoTMalloc(AutoTMalloc&&) = default;
+    AutoTMalloc& operator=(AutoTMalloc&&) = default;
 
     /** Resize the memory area pointed to by the current ptr preserving contents. */
     void realloc(size_t count) {
@@ -283,18 +300,18 @@ public:
     T* release() { return fPtr.release(); }
 
 private:
-    std::unique_ptr<T, SkFunctionWrapper<void(void*), sk_free>> fPtr;
+    std::unique_ptr<T, SkOverloadedFunctionObject<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 {
+class AutoSTMalloc {
 public:
-    SkAutoSTMalloc() : fPtr(fTStorage) {}
+    AutoSTMalloc() : fPtr(fTStorage) {}
 
-    SkAutoSTMalloc(size_t count) {
+    AutoSTMalloc(size_t count) {
         if (count > kCount) {
             fPtr = (T*)sk_malloc_throw(count, sizeof(T));
         } else if (count) {
@@ -304,12 +321,12 @@ public:
         }
     }
 
-    SkAutoSTMalloc(SkAutoSTMalloc&&) = delete;
-    SkAutoSTMalloc(const SkAutoSTMalloc&) = delete;
-    SkAutoSTMalloc& operator=(SkAutoSTMalloc&&) = delete;
-    SkAutoSTMalloc& operator=(const SkAutoSTMalloc&) = delete;
+    AutoSTMalloc(AutoSTMalloc&&) = delete;
+    AutoSTMalloc(const AutoSTMalloc&) = delete;
+    AutoSTMalloc& operator=(AutoSTMalloc&&) = delete;
+    AutoSTMalloc& operator=(const AutoSTMalloc&) = delete;
 
-    ~SkAutoSTMalloc() {
+    ~AutoSTMalloc() {
         if (fPtr != fTStorage) {
             sk_free(fPtr);
         }
@@ -391,27 +408,9 @@ private:
     };
 };
 
-//////////////////////////////////////////////////////////////////////////////////////////////////
+using UniqueVoidPtr = std::unique_ptr<void, SkOverloadedFunctionObject<void(void*), sk_free>>;
 
-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>>;
+}  // namespace skia_private
 
 template<typename C, std::size_t... Is>
 constexpr auto SkMakeArrayFromIndexSequence(C c, std::index_sequence<Is...> is)
@@ -424,28 +423,4 @@ template<size_t N, typename C> constexpr auto SkMakeArray(C c)
     return SkMakeArrayFromIndexSequence(c, std::make_index_sequence<N>{});
 }
 
-/**
- * Trait for identifying types which are relocatable via memcpy, for container optimizations.
- *
- */
-template<typename, typename = void>
-struct sk_has_trivially_relocatable_member : std::false_type {};
-
-// Types can declare themselves trivially relocatable with a public
-//    using sk_is_trivially_relocatable = std::true_type;
-template<typename T>
-struct sk_has_trivially_relocatable_member<T, std::void_t<typename T::sk_is_trivially_relocatable>>
-        : T::sk_is_trivially_relocatable {};
-
-// By default, all trivially copyable types are trivially relocatable.
-template <typename T>
-struct sk_is_trivially_relocatable
-        : std::disjunction<std::is_trivially_copyable<T>, sk_has_trivially_relocatable_member<T>
->{};
-
-// Here be some dragons: while technically not guaranteed, we count on all sane unique_ptr
-// implementations to be trivially relocatable.
-template <typename T>
-struct sk_is_trivially_relocatable<std::unique_ptr<T>> : std::true_type {};
-
 #endif

package/cpp/skia/include/private/{SkThreadID.h → base/SkThreadID.h}

@@ -8,11 +8,14 @@
 #ifndef SkThreadID_DEFINED
 #define SkThreadID_DEFINED
 
-#include "include/core/SkTypes.h"
+#include "include/private/base/SkAPI.h"
+#include "include/private/base/SkDebug.h"
+
+#include <cstdint>
 
 typedef int64_t SkThreadID;
 
-// SkMutex.h uses SkGetThredID in debug only code.
+// SkMutex.h uses SkGetThreadID in debug only code.
 SkDEBUGCODE(SK_SPI) SkThreadID SkGetThreadID();
 
 const SkThreadID kIllegalThreadID = 0;

package/cpp/skia/include/private/{SkTo.h → base/SkTo.h}

@@ -7,8 +7,11 @@
 #ifndef SkTo_DEFINED
 #define SkTo_DEFINED
 
-#include "include/core/SkTypes.h"
-#include "include/private/SkTFitsIn.h"
+#include "include/private/base/SkAssert.h"
+#include "include/private/base/SkTFitsIn.h"
+
+#include <cstddef>
+#include <cstdint>
 
 template <typename D, typename S> constexpr D SkTo(S s) {
     return SkASSERT(SkTFitsIn<D>(s)),
@@ -21,8 +24,16 @@ 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 int64_t  SkToS64(S x)   { return SkTo<int64_t>(x);  }
+template <typename S> constexpr uint64_t SkToU64(S x)   { return SkTo<uint64_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);   }
 
+/** @return false or true based on the condition
+*/
+template <typename T> static constexpr bool SkToBool(const T& x) {
+    return (bool)x;
+}
+
 #endif  // SkTo_DEFINED

package/cpp/skia/include/private/base/SkTypeTraits.h

@@ -0,0 +1,33 @@
+// 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 SkTypeTraits_DEFINED
+#define SkTypeTraits_DEFINED
+
+#include <memory>
+#include <type_traits>
+
+// Trait for identifying types which are relocatable via memcpy, for container optimizations.
+template<typename, typename = void>
+struct sk_has_trivially_relocatable_member : std::false_type {};
+
+// Types can declare themselves trivially relocatable with a public
+//    using sk_is_trivially_relocatable = std::true_type;
+template<typename T>
+struct sk_has_trivially_relocatable_member<T, std::void_t<typename T::sk_is_trivially_relocatable>>
+        : T::sk_is_trivially_relocatable {};
+
+// By default, all trivially copyable types are trivially relocatable.
+template <typename T>
+struct sk_is_trivially_relocatable
+        : std::disjunction<std::is_trivially_copyable<T>, sk_has_trivially_relocatable_member<T>>{};
+
+// Here be some dragons: while technically not guaranteed, we count on all sane unique_ptr
+// implementations to be trivially relocatable.
+template <typename T>
+struct sk_is_trivially_relocatable<std::unique_ptr<T>> : std::true_type {};
+
+template <typename T>
+inline constexpr bool sk_is_trivially_relocatable_v = sk_is_trivially_relocatable<T>::value;
+
+#endif  // SkTypeTraits_DEFINED