@shopify/react-native-skia 0.1.192 → 0.1.194

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

@@ -8,36 +8,25 @@
 #ifndef SkPathRef_DEFINED
 #define SkPathRef_DEFINED
 
-#include "include/core/SkMatrix.h"
 #include "include/core/SkPoint.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
 #include "include/private/SkIDChangeListener.h"
-#include "include/private/SkMutex.h"
-#include "include/private/SkTDArray.h"
-#include "include/private/SkTemplates.h"
-#include "include/private/SkTo.h"
+#include "include/private/base/SkDebug.h"
+#include "include/private/base/SkTArray.h"
+#include "include/private/base/SkTo.h"
 
 #include <atomic>
-#include <limits>
+#include <cstddef>
+#include <cstdint>
 #include <tuple>
+#include <utility>
 
-class SkRBuffer;
-class SkWBuffer;
+class SkMatrix;
 class SkRRect;
 
-enum class SkPathConvexity {
-    kConvex,
-    kConcave,
-    kUnknown,
-};
-
-enum class SkPathFirstDirection {
-    kCW,         // == SkPathDirection::kCW
-    kCCW,        // == SkPathDirection::kCCW
-    kUnknown,
-};
-
 // These are computed from a stream of verbs
 struct SkPathVerbAnalysis {
     bool     valid;
@@ -64,7 +53,13 @@ SkPathVerbAnalysis sk_path_analyze_verbs(const uint8_t verbs[], int count);
 
 class SK_API SkPathRef final : public SkNVRefCnt<SkPathRef> {
 public:
-    SkPathRef(SkTDArray<SkPoint> points, SkTDArray<uint8_t> verbs, SkTDArray<SkScalar> weights,
+    // See https://bugs.chromium.org/p/skia/issues/detail?id=13817 for how these sizes were
+    // determined.
+    using PointsArray = skia_private::STArray<4, SkPoint>;
+    using VerbsArray = skia_private::STArray<4, uint8_t>;
+    using ConicWeightsArray = skia_private::STArray<2, SkScalar>;
+
+    SkPathRef(PointsArray points, VerbsArray verbs, ConicWeightsArray weights,
               unsigned segmentMask)
         : fPoints(std::move(points))
         , fVerbs(std::move(verbs))
@@ -320,24 +315,15 @@ public:
 
     bool operator== (const SkPathRef& ref) const;
 
-    /**
-     * Writes the path points and verbs to a buffer.
-     */
-    void writeToBuffer(SkWBuffer* buffer) const;
-
-    /**
-     * Gets the number of bytes that would be written in writeBuffer()
-     */
-    uint32_t writeSize() const;
-
     void interpolate(const SkPathRef& ending, SkScalar weight, SkPathRef* out) const;
 
     /**
      * Gets an ID that uniquely identifies the contents of the path ref. If two path refs have the
      * same ID then they have the same verbs and points. However, two path refs may have the same
      * contents but different genIDs.
+     * skbug.com/1762 for background on why fillType is necessary (for now).
      */
-    uint32_t genID() const;
+    uint32_t genID(uint8_t fillType) const;
 
     void addGenIDChangeListener(sk_sp<SkIDChangeListener>);   // Threadsafe.
     int genIDChangeListenerCount();                           // Threadsafe
@@ -346,6 +332,15 @@ public:
     bool isValid() const;
     SkDEBUGCODE(void validate() const { SkASSERT(this->isValid()); } )
 
+    /**
+     * Resets this SkPathRef to a clean state.
+     */
+    void reset();
+
+    bool isInitialEmptyPathRef() const {
+        return fGenerationID == kEmptyGenID;
+    }
+
 private:
     enum SerializationOffsets {
         kLegacyRRectOrOvalStartIdx_SerializationShift = 28, // requires 3 bits, ignored.
@@ -356,7 +351,7 @@ private:
         kSegmentMask_SerializationShift = 0                 // requires 4 bits (deprecated)
     };
 
-    SkPathRef() {
+    SkPathRef(int numVerbs = 0, int numPoints = 0) {
         fBoundsIsDirty = true;    // this also invalidates fIsFinite
         fGenerationID = kEmptyGenID;
         fSegmentMask = 0;
@@ -365,6 +360,10 @@ private:
         // The next two values don't matter unless fIsOval or fIsRRect are true.
         fRRectOrOvalIsCCW = false;
         fRRectOrOvalStartIdx = 0xAC;
+        if (numPoints > 0)
+            fPoints.reserve_back(numPoints);
+        if (numVerbs > 0)
+            fVerbs.reserve_back(numVerbs);
         SkDEBUGCODE(fEditorsAttached.store(0);)
         SkDEBUGCODE(this->validate();)
     }
@@ -397,15 +396,20 @@ private:
     /** Makes additional room but does not change the counts or change the genID */
     void incReserve(int additionalVerbs, int additionalPoints) {
         SkDEBUGCODE(this->validate();)
-        fPoints.reserve(fPoints.size() + additionalPoints);
-        fVerbs.reserve(fVerbs.size() + additionalVerbs);
+        // Use reserve() so that if there is not enough space, the array will grow with some
+        // additional space. This ensures repeated calls to grow won't always allocate.
+        if (additionalPoints > 0)
+            fPoints.reserve(fPoints.size() + additionalPoints);
+        if (additionalVerbs > 0)
+            fVerbs.reserve(fVerbs.size() + additionalVerbs);
         SkDEBUGCODE(this->validate();)
     }
 
-    /** Resets the path ref with verbCount verbs and pointCount points, all uninitialized. Also
-     *  allocates space for reserveVerb additional verbs and reservePoints additional points.*/
-    void resetToSize(int verbCount, int pointCount, int conicCount,
-                     int reserveVerbs = 0, int reservePoints = 0) {
+    /**
+     * Resets all state except that of the verbs, points, and conic-weights.
+     * Intended to be called from other functions that reset state.
+     */
+    void commonReset() {
         SkDEBUGCODE(this->validate();)
         this->callGenIDChangeListeners();
         fBoundsIsDirty = true;      // this also invalidates fIsFinite
@@ -414,12 +418,25 @@ private:
         fSegmentMask = 0;
         fIsOval = false;
         fIsRRect = false;
+    }
 
-        fPoints.reserve(pointCount + reservePoints);
-        fPoints.resize(pointCount);
-        fVerbs.reserve(verbCount + reserveVerbs);
-        fVerbs.resize(verbCount);
-        fConicWeights.resize(conicCount);
+    /** Resets the path ref with verbCount verbs and pointCount points, all uninitialized. Also
+     *  allocates space for reserveVerb additional verbs and reservePoints additional points.*/
+    void resetToSize(int verbCount, int pointCount, int conicCount,
+                     int reserveVerbs = 0, int reservePoints = 0) {
+        commonReset();
+        // Use reserve_back() so the arrays are sized to exactly fit the data.
+        const int pointDelta = pointCount + reservePoints - fPoints.size();
+        if (pointDelta > 0) {
+            fPoints.reserve_back(pointDelta);
+        }
+        fPoints.resize_back(pointCount);
+        const int verbDelta = verbCount + reserveVerbs - fVerbs.size();
+        if (verbDelta > 0) {
+            fVerbs.reserve_back(verbDelta);
+        }
+        fVerbs.resize_back(verbCount);
+        fConicWeights.resize_back(conicCount);
         SkDEBUGCODE(this->validate();)
     }
 
@@ -489,9 +506,9 @@ private:
 
     mutable SkRect   fBounds;
 
-    SkTDArray<SkPoint>  fPoints;
-    SkTDArray<uint8_t>  fVerbs;
-    SkTDArray<SkScalar> fConicWeights;
+    PointsArray fPoints;
+    VerbsArray fVerbs;
+    ConicWeightsArray fConicWeights;
 
     enum {
         kEmptyGenID = 1, // GenID reserved for path ref with zero points and zero verbs.

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

@@ -11,7 +11,7 @@
 #include <cstdint>
 
 #include "include/core/SkTypes.h"
-#include "include/private/SkTArray.h"
+#include "include/private/base/SkTArray.h"
 
 using SKSL_INT = int64_t;
 using SKSL_FLOAT = float;
@@ -21,17 +21,17 @@ namespace SkSL {
 class Expression;
 class Statement;
 
-using ComponentArray = SkSTArray<4, int8_t>; // for Swizzles
+using ComponentArray = skia_private::STArray<4, int8_t>; // for Swizzles
 
-class ExpressionArray : public SkSTArray<2, std::unique_ptr<Expression>> {
+class ExpressionArray : public skia_private::STArray<2, std::unique_ptr<Expression>> {
 public:
-    using SkSTArray::SkSTArray;
+    using STArray::STArray;
 
     /** Returns a new ExpressionArray containing a clone of every element. */
     ExpressionArray clone() const;
 };
 
-using StatementArray = SkSTArray<2, std::unique_ptr<Statement>>;
+using StatementArray = skia_private::STArray<2, std::unique_ptr<Statement>>;
 
 // Functions larger than this (measured in IR nodes) will not be inlined. This growth factor
 // accounts for the number of calls being inlined--i.e., a function called five times (that is, with

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

@@ -10,8 +10,6 @@
 
 #include "include/core/SkTypes.h"
 
-#include <string>
-
 namespace SkSL {
 
 /**
@@ -77,8 +75,6 @@ public:
     bool isUniformMatrix() const { return fKind == Kind::kUniformMatrix; }
     bool isFragCoord()     const { return fKind == Kind::kFragCoord; }
 
-    std::string constructor() const;
-
 private:
     Kind fKind = Kind::kNone;
     bool fHasPerspective = false;  // Only valid if fKind is kUniformMatrix

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

@@ -9,7 +9,7 @@
 #define SkSpinlock_DEFINED
 
 #include "include/core/SkTypes.h"
-#include "include/private/SkThreadAnnotations.h"
+#include "include/private/base/SkThreadAnnotations.h"
 #include <atomic>
 
 class SK_CAPABILITY("mutex") SkSpinlock {

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

@@ -9,7 +9,10 @@
 #define SkWeakRefCnt_DEFINED
 
 #include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
 #include <atomic>
+#include <cstdint>
 
 /** \class SkWeakRefCnt
 

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

@@ -8,16 +8,19 @@
 #ifndef skgpu_SingleOwner_DEFINED
 #define skgpu_SingleOwner_DEFINED
 
-#include "include/core/SkTypes.h"
+#include "include/private/base/SkDebug.h" // IWYU pragma: keep
+
+#if defined(SK_DEBUG)
+#include "include/private/base/SkAssert.h"
+#include "include/private/base/SkMutex.h"
+#include "include/private/base/SkThreadAnnotations.h"
+#include "include/private/base/SkThreadID.h"
 
-#ifdef SK_DEBUG
-#include "include/private/SkMutex.h"
-#include "include/private/SkThreadID.h"
 #endif
 
 namespace skgpu {
 
-#ifdef SK_DEBUG
+#if defined(SK_DEBUG)
 
 #define SKGPU_ASSERT_SINGLE_OWNER(obj) \
     skgpu::SingleOwner::AutoEnforce debug_SingleOwner(obj, __FILE__, __LINE__);

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

@@ -0,0 +1,52 @@
+/*
+ * 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 SkAPI_DEFINED
+#define SkAPI_DEFINED
+
+#include "include/private/base/SkLoadUserConfig.h" // IWYU pragma: keep
+
+// If SKIA_IMPLEMENTATION is defined as 1, that signals we are building Skia and should
+// export our symbols. If it is not set (or set to 0), then Skia is being used by a client
+// and we should not export our symbols.
+#if !defined(SKIA_IMPLEMENTATION)
+    #define SKIA_IMPLEMENTATION 0
+#endif
+
+// If we are compiling Skia is being as a DLL, we need to be sure to export all of our public
+// APIs to that DLL. If a client is using Skia which was compiled as a DLL, we need to instruct
+// the linker to use the symbols from that DLL. This is the goal of the SK_API define.
+#if !defined(SK_API)
+    #if defined(SKIA_DLL)
+        #if defined(_MSC_VER)
+            #if SKIA_IMPLEMENTATION
+                #define SK_API __declspec(dllexport)
+            #else
+                #define SK_API __declspec(dllimport)
+            #endif
+        #else
+            #define SK_API __attribute__((visibility("default")))
+        #endif
+    #else
+        #define SK_API
+    #endif
+#endif
+
+// SK_SPI is functionally identical to SK_API, but used within src to clarify that it's less stable
+#if !defined(SK_SPI)
+    #define SK_SPI SK_API
+#endif
+
+// See https://clang.llvm.org/docs/AttributeReference.html#availability
+// The API_AVAILABLE macro comes from <os/availability.h> on MacOS
+#if defined(SK_ENABLE_API_AVAILABLE)
+#   define SK_API_AVAILABLE API_AVAILABLE
+#else
+#   define SK_API_AVAILABLE(...)
+#endif
+
+#endif

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

@@ -0,0 +1,39 @@
+/*
+ * 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 SkAlign_DEFINED
+#define SkAlign_DEFINED
+
+#include "include/private/base/SkAssert.h"
+
+#include <cstddef>
+
+template <typename T> static constexpr T SkAlign2(T x) { return (x + 1) >> 1 << 1; }
+template <typename T> static constexpr T SkAlign4(T x) { return (x + 3) >> 2 << 2; }
+template <typename T> static constexpr T SkAlign8(T x) { return (x + 7) >> 3 << 3; }
+
+template <typename T> static constexpr bool SkIsAlign2(T x) { return 0 == (x & 1); }
+template <typename T> static constexpr bool SkIsAlign4(T x) { return 0 == (x & 3); }
+template <typename T> static constexpr bool SkIsAlign8(T x) { return 0 == (x & 7); }
+
+template <typename T> static constexpr T SkAlignPtr(T x) {
+    return sizeof(void*) == 8 ? SkAlign8(x) : SkAlign4(x);
+}
+template <typename T> static constexpr bool SkIsAlignPtr(T x) {
+    return sizeof(void*) == 8 ? SkIsAlign8(x) : SkIsAlign4(x);
+}
+
+/**
+ *  align up to a power of 2
+ */
+static inline constexpr size_t SkAlignTo(size_t x, size_t alignment) {
+    // The same as alignment && SkIsPow2(value), w/o a dependency cycle.
+    SkASSERT(alignment && (alignment & (alignment - 1)) == 0);
+    return (x + alignment - 1) & ~(alignment - 1);
+}
+
+#endif

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

@@ -0,0 +1,32 @@
+// 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 SkAlignedStorage_DEFINED
+#define SkAlignedStorage_DEFINED
+
+#include <cstddef>
+#include <iterator>
+
+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; }
+
+    // Act as a container of bytes because the storage is uninitialized.
+    std::byte* data() { return fStorage; }
+    const std::byte* data() const { return fStorage; }
+    size_t size() const { return std::size(fStorage); }
+
+private:
+    alignas(T) std::byte fStorage[sizeof(T) * N];
+};
+
+#endif  // SkAlignedStorage_DEFINED

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

@@ -0,0 +1,92 @@
+/*
+ * 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 SkAssert_DEFINED
+#define SkAssert_DEFINED
+
+#include "include/private/base/SkAPI.h"
+#include "include/private/base/SkDebug.h" // IWYU pragma: keep
+
+/** Called internally if we hit an unrecoverable error.
+    The platform implementation must not return, but should either throw
+    an exception or otherwise exit.
+*/
+[[noreturn]] SK_API extern void sk_abort_no_print(void);
+
+#if defined(SK_BUILD_FOR_GOOGLE3)
+    void SkDebugfForDumpStackTrace(const char* data, void* unused);
+    namespace base {
+        void DumpStackTrace(int skip_count, void w(const char*, void*), void* arg);
+    }
+#  define SK_DUMP_GOOGLE3_STACK() ::base::DumpStackTrace(0, SkDebugfForDumpStackTrace, nullptr)
+#else
+#  define SK_DUMP_GOOGLE3_STACK()
+#endif
+
+#if !defined(SK_ABORT)
+#  if defined(SK_BUILD_FOR_WIN)
+     // This style lets Visual Studio follow errors back to the source file.
+#    define SK_DUMP_LINE_FORMAT "%s(%d)"
+#  else
+#    define SK_DUMP_LINE_FORMAT "%s:%d"
+#  endif
+#  define SK_ABORT(message, ...) \
+    do { \
+        SkDebugf(SK_DUMP_LINE_FORMAT ": fatal error: \"" message "\"\n", \
+                 __FILE__, __LINE__, ##__VA_ARGS__); \
+        SK_DUMP_GOOGLE3_STACK(); \
+        sk_abort_no_print(); \
+    } while (false)
+#endif
+
+// SkASSERT, SkASSERTF and SkASSERT_RELEASE can be used as stand alone assertion expressions, e.g.
+//    uint32_t foo(int x) {
+//        SkASSERT(x > 4);
+//        return x - 4;
+//    }
+// and are also written to be compatible with constexpr functions:
+//    constexpr uint32_t foo(int x) {
+//        return SkASSERT(x > 4),
+//               x - 4;
+//    }
+#define SkASSERT_RELEASE(cond) \
+        static_cast<void>( (cond) ? (void)0 : []{ SK_ABORT("assert(%s)", #cond); }() )
+
+#if defined(SK_DEBUG)
+    #define SkASSERT(cond) SkASSERT_RELEASE(cond)
+    #define SkASSERTF(cond, fmt, ...) static_cast<void>( (cond) ? (void)0 : [&]{ \
+                                          SkDebugf(fmt"\n", ##__VA_ARGS__);      \
+                                          SK_ABORT("assert(%s)", #cond);         \
+                                      }() )
+    #define SkDEBUGFAIL(message)        SK_ABORT("%s", message)
+    #define SkDEBUGFAILF(fmt, ...)      SK_ABORT(fmt, ##__VA_ARGS__)
+    #define SkAssertResult(cond)        SkASSERT(cond)
+#else
+    #define SkASSERT(cond)            static_cast<void>(0)
+    #define SkASSERTF(cond, fmt, ...) static_cast<void>(0)
+    #define SkDEBUGFAIL(message)
+    #define SkDEBUGFAILF(fmt, ...)
+
+    // unlike SkASSERT, this macro executes its condition in the non-debug build.
+    // The if is present so that this can be used with functions marked SK_WARN_UNUSED_RESULT.
+    #define SkAssertResult(cond)         if (cond) {} do {} while(false)
+#endif
+
+#if !defined(SkUNREACHABLE)
+#  if defined(_MSC_VER) && !defined(__clang__)
+#    include <intrin.h>
+#    define FAST_FAIL_INVALID_ARG                 5
+// See https://developercommunity.visualstudio.com/content/problem/1128631/code-flow-doesnt-see-noreturn-with-extern-c.html
+// for why this is wrapped. Hopefully removable after msvc++ 19.27 is no longer supported.
+[[noreturn]] static inline void sk_fast_fail() { __fastfail(FAST_FAIL_INVALID_ARG); }
+#    define SkUNREACHABLE sk_fast_fail()
+#  else
+#    define SkUNREACHABLE __builtin_trap()
+#  endif
+#endif
+
+#endif

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

@@ -0,0 +1,102 @@
+/*
+ * 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 SkAttributes_DEFINED
+#define SkAttributes_DEFINED
+
+#include "include/private/base/SkFeatures.h" // IWYU pragma: keep
+#include "include/private/base/SkLoadUserConfig.h" // IWYU pragma: keep
+
+#if defined(__clang__) || defined(__GNUC__)
+#  define SK_ATTRIBUTE(attr) __attribute__((attr))
+#else
+#  define SK_ATTRIBUTE(attr)
+#endif
+
+#if !defined(SK_UNUSED)
+#  if !defined(__clang__) && defined(_MSC_VER)
+#    define SK_UNUSED __pragma(warning(suppress:4189))
+#  else
+#    define SK_UNUSED SK_ATTRIBUTE(unused)
+#  endif
+#endif
+
+#if !defined(SK_WARN_UNUSED_RESULT)
+    #define SK_WARN_UNUSED_RESULT SK_ATTRIBUTE(warn_unused_result)
+#endif
+
+/**
+ * If your judgment is better than the compiler's (i.e. you've profiled it),
+ * you can use SK_ALWAYS_INLINE to force inlining. E.g.
+ *     inline void someMethod() { ... }             // may not be inlined
+ *     SK_ALWAYS_INLINE void someMethod() { ... }   // should always be inlined
+ */
+#if !defined(SK_ALWAYS_INLINE)
+#  if defined(SK_BUILD_FOR_WIN)
+#    define SK_ALWAYS_INLINE __forceinline
+#  else
+#    define SK_ALWAYS_INLINE SK_ATTRIBUTE(always_inline) inline
+#  endif
+#endif
+
+/**
+ * If your judgment is better than the compiler's (i.e. you've profiled it),
+ * you can use SK_NEVER_INLINE to prevent inlining.
+ */
+#if !defined(SK_NEVER_INLINE)
+#  if defined(SK_BUILD_FOR_WIN)
+#    define SK_NEVER_INLINE __declspec(noinline)
+#  else
+#    define SK_NEVER_INLINE SK_ATTRIBUTE(noinline)
+#  endif
+#endif
+
+/**
+ * Used to annotate a function as taking printf style arguments.
+ * `A` is the (1 based) index of the format string argument.
+ * `B` is the (1 based) index of the first argument used by the format string.
+ */
+#if !defined(SK_PRINTF_LIKE)
+#  define SK_PRINTF_LIKE(A, B) SK_ATTRIBUTE(format(printf, (A), (B)))
+#endif
+
+/**
+ * Used to ignore sanitizer warnings.
+ */
+#if !defined(SK_NO_SANITIZE)
+#  define SK_NO_SANITIZE(A) SK_ATTRIBUTE(no_sanitize(A))
+#endif
+
+/**
+ * Helper macro to define no_sanitize attributes only with clang.
+ */
+#if defined(__clang__) && defined(__has_attribute)
+  #if __has_attribute(no_sanitize)
+    #define SK_CLANG_NO_SANITIZE(A) SK_NO_SANITIZE(A)
+  #endif
+#endif
+
+#if !defined(SK_CLANG_NO_SANITIZE)
+  #define SK_CLANG_NO_SANITIZE(A)
+#endif
+
+/**
+ * Annotates a class' non-trivial special functions as trivial for the purposes of calls.
+ * Allows a class with a non-trivial destructor to be __is_trivially_relocatable.
+ * Use of this attribute on a public API breaks platform ABI.
+ * Annotated classes may not hold pointers derived from `this`.
+ * Annotated classes must implement move+delete as equivalent to memcpy+free.
+ * Use may require more complete types, as callee destroys.
+ *
+ * https://clang.llvm.org/docs/AttributeReference.html#trivial-abi
+ * https://libcxx.llvm.org/DesignDocs/UniquePtrTrivialAbi.html
+ */
+#if !defined(SK_TRIVIAL_ABI)
+#  define SK_TRIVIAL_ABI
+#endif
+
+#endif

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

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkCPUTypes_DEFINED
+#define SkCPUTypes_DEFINED
+
+// TODO(bungeman,kjlubick) There are a lot of assumptions throughout the codebase that
+//   these types are 32 bits, when they could be more or less. Public APIs should stop
+//   using these. Internally, we could use uint_fast8_t and uint_fast16_t, but not in
+//   public APIs due to ABI incompatibilities.
+
+/** Fast type for unsigned 8 bits. Use for parameter passing and local
+    variables, not for storage
+*/
+typedef unsigned U8CPU;
+
+/** Fast type for unsigned 16 bits. Use for parameter passing and local
+    variables, not for storage
+*/
+typedef unsigned U16CPU;
+
+#endif

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

@@ -0,0 +1,46 @@
+// 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 SkContainers_DEFINED
+#define SkContainers_DEFINED
+
+#include "include/private/base/SkAPI.h"
+#include "include/private/base/SkSpan_impl.h"
+
+#include <cstddef>
+#include <cstdint>
+
+class SK_SPI SkContainerAllocator {
+public:
+    SkContainerAllocator(size_t sizeOfT, int maxCapacity)
+            : fSizeOfT{sizeOfT}
+            , fMaxCapacity{maxCapacity} {}
+
+    // allocate will abort on failure. Given a capacity of 0, it will return the empty span.
+    // The bytes allocated are freed using sk_free().
+    SkSpan<std::byte> allocate(int capacity, double growthFactor = 1.0);
+
+private:
+    friend struct SkContainerAllocatorTestingPeer;
+    // All capacity counts will be rounded up to kCapacityMultiple.
+    // TODO: this is a constant from the original SkTArray code. This should be checked some how.
+    static constexpr int64_t kCapacityMultiple = 8;
+
+    // Rounds up capacity to next multiple of kCapacityMultiple and pin to fMaxCapacity.
+    size_t roundUpCapacity(int64_t capacity) const;
+
+    // Grows the capacity by growthFactor being sure to stay with in kMinBytes and fMaxCapacity.
+    size_t growthFactorCapacity(int capacity, double growthFactor) const;
+
+    const size_t fSizeOfT;
+    const int64_t fMaxCapacity;
+};
+
+// sk_allocate_canfail returns the empty span on failure. Parameter size must be > 0.
+SkSpan<std::byte> sk_allocate_canfail(size_t size);
+
+// Returns the empty span if size is 0. sk_allocate_throw aborts on failure.
+SkSpan<std::byte> sk_allocate_throw(size_t size);
+
+SK_SPI void sk_report_container_overflow_and_die();
+#endif  // SkContainers_DEFINED