@shopify/react-native-skia 0.1.192 → 0.1.194

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

@@ -0,0 +1,27 @@
+/*
+ * 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 SkDebug_DEFINED
+#define SkDebug_DEFINED
+
+#include "include/private/base/SkAPI.h"
+#include "include/private/base/SkAttributes.h"
+#include "include/private/base/SkLoadUserConfig.h" // IWYU pragma: keep
+
+#if !defined(SkDebugf)
+    void SK_SPI SkDebugf(const char format[], ...) SK_PRINTF_LIKE(1, 2);
+#endif
+
+#if defined(SK_DEBUG)
+    #define SkDEBUGCODE(...)  __VA_ARGS__
+    #define SkDEBUGF(...)     SkDebugf(__VA_ARGS__)
+#else
+    #define SkDEBUGCODE(...)
+    #define SkDEBUGF(...)
+#endif
+
+#endif

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

@@ -10,7 +10,9 @@
 #ifndef SkDeque_DEFINED
 #define SkDeque_DEFINED
 
-#include "include/core/SkTypes.h"
+#include "include/private/base/SkAPI.h"
+
+#include <cstddef>
 
 /*
  * The deque class works by blindly creating memory space of a specified element

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

@@ -0,0 +1,151 @@
+/*
+ * 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 SkFeatures_DEFINED
+#define SkFeatures_DEFINED
+
+#if !defined(SK_BUILD_FOR_ANDROID) && !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_WIN) && \
+    !defined(SK_BUILD_FOR_UNIX) && !defined(SK_BUILD_FOR_MAC)
+
+    #ifdef __APPLE__
+        #include <TargetConditionals.h>
+    #endif
+
+    #if defined(_WIN32) || defined(__SYMBIAN32__)
+        #define SK_BUILD_FOR_WIN
+    #elif defined(ANDROID) || defined(__ANDROID__)
+        #define SK_BUILD_FOR_ANDROID
+    #elif defined(linux) || defined(__linux) || defined(__FreeBSD__) || \
+          defined(__OpenBSD__) || defined(__sun) || defined(__NetBSD__) || \
+          defined(__DragonFly__) || defined(__Fuchsia__) || \
+          defined(__GLIBC__) || defined(__GNU__) || defined(__unix__)
+        #define SK_BUILD_FOR_UNIX
+    #elif TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
+        #define SK_BUILD_FOR_IOS
+    #else
+        #define SK_BUILD_FOR_MAC
+    #endif
+#endif // end SK_BUILD_FOR_*
+
+
+#if defined(SK_BUILD_FOR_WIN) && !defined(__clang__)
+    #if !defined(SK_RESTRICT)
+        #define SK_RESTRICT __restrict
+    #endif
+    #if !defined(SK_WARN_UNUSED_RESULT)
+        #define SK_WARN_UNUSED_RESULT
+    #endif
+#endif
+
+#if !defined(SK_RESTRICT)
+    #define SK_RESTRICT __restrict__
+#endif
+
+#if !defined(SK_CPU_BENDIAN) && !defined(SK_CPU_LENDIAN)
+    #if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+        #define SK_CPU_BENDIAN
+    #elif defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+        #define SK_CPU_LENDIAN
+    #elif defined(__sparc) || defined(__sparc__) || \
+      defined(_POWER) || defined(__powerpc__) || \
+      defined(__ppc__) || defined(__hppa) || \
+      defined(__PPC__) || defined(__PPC64__) || \
+      defined(_MIPSEB) || defined(__ARMEB__) || \
+      defined(__s390__) || \
+      (defined(__sh__) && defined(__BIG_ENDIAN__)) || \
+      (defined(__ia64) && defined(__BIG_ENDIAN__))
+         #define SK_CPU_BENDIAN
+    #else
+        #define SK_CPU_LENDIAN
+    #endif
+#endif
+
+#if defined(__i386) || defined(_M_IX86) ||  defined(__x86_64__) || defined(_M_X64)
+  #define SK_CPU_X86 1
+#endif
+
+/**
+ *  SK_CPU_SSE_LEVEL
+ *
+ *  If defined, SK_CPU_SSE_LEVEL should be set to the highest supported level.
+ *  On non-intel CPU this should be undefined.
+ */
+#define SK_CPU_SSE_LEVEL_SSE1     10
+#define SK_CPU_SSE_LEVEL_SSE2     20
+#define SK_CPU_SSE_LEVEL_SSE3     30
+#define SK_CPU_SSE_LEVEL_SSSE3    31
+#define SK_CPU_SSE_LEVEL_SSE41    41
+#define SK_CPU_SSE_LEVEL_SSE42    42
+#define SK_CPU_SSE_LEVEL_AVX      51
+#define SK_CPU_SSE_LEVEL_AVX2     52
+#define SK_CPU_SSE_LEVEL_SKX      60
+
+// TODO(brianosman,kjlubick) clean up these checks
+
+// Are we in GCC/Clang?
+#ifndef SK_CPU_SSE_LEVEL
+    // These checks must be done in descending order to ensure we set the highest
+    // available SSE level.
+    #if defined(__AVX512F__) && defined(__AVX512DQ__) && defined(__AVX512CD__) && \
+        defined(__AVX512BW__) && defined(__AVX512VL__)
+        #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_SKX
+    #elif defined(__AVX2__)
+        #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_AVX2
+    #elif defined(__AVX__)
+        #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_AVX
+    #elif defined(__SSE4_2__)
+        #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_SSE42
+    #elif defined(__SSE4_1__)
+        #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_SSE41
+    #elif defined(__SSSE3__)
+        #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_SSSE3
+    #elif defined(__SSE3__)
+        #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_SSE3
+    #elif defined(__SSE2__)
+        #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_SSE2
+    #endif
+#endif
+
+// Are we in VisualStudio?
+#ifndef SK_CPU_SSE_LEVEL
+    // These checks must be done in descending order to ensure we set the highest
+    // available SSE level. 64-bit intel guarantees at least SSE2 support.
+    #if defined(__AVX512F__) && defined(__AVX512DQ__) && defined(__AVX512CD__) && \
+        defined(__AVX512BW__) && defined(__AVX512VL__)
+        #define SK_CPU_SSE_LEVEL        SK_CPU_SSE_LEVEL_SKX
+    #elif defined(__AVX2__)
+        #define SK_CPU_SSE_LEVEL        SK_CPU_SSE_LEVEL_AVX2
+    #elif defined(__AVX__)
+        #define SK_CPU_SSE_LEVEL        SK_CPU_SSE_LEVEL_AVX
+    #elif defined(_M_X64) || defined(_M_AMD64)
+        #define SK_CPU_SSE_LEVEL        SK_CPU_SSE_LEVEL_SSE2
+    #elif defined(_M_IX86_FP)
+        #if _M_IX86_FP >= 2
+            #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_SSE2
+        #elif _M_IX86_FP == 1
+            #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_SSE1
+        #endif
+    #endif
+#endif
+
+// ARM defines
+#if defined(__arm__) && (!defined(__APPLE__) || !TARGET_IPHONE_SIMULATOR)
+    #define SK_CPU_ARM32
+#elif defined(__aarch64__)
+    #define SK_CPU_ARM64
+#endif
+
+// All 64-bit ARM chips have NEON.  Many 32-bit ARM chips do too.
+#if !defined(SK_ARM_HAS_NEON) && defined(__ARM_NEON)
+    #define SK_ARM_HAS_NEON
+#endif
+
+#if defined(__ARM_FEATURE_CRC32)
+    #define SK_ARM_HAS_CRC32
+#endif
+
+#endif // SkFeatures_DEFINED

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

@@ -8,11 +8,12 @@
 #ifndef SkFixed_DEFINED
 #define SkFixed_DEFINED
 
-#include "include/core/SkScalar.h"
-#include "include/core/SkTypes.h"
-#include "include/private/SkSafe_math.h"
-#include "include/private/SkTPin.h"
-#include "include/private/SkTo.h"
+#include "include/private/base/SkAssert.h"
+#include "include/private/base/SkDebug.h"
+#include "include/private/base/SkMath.h" // IWYU pragma: keep
+#include "include/private/base/SkTPin.h" // IWYU pragma: keep
+
+#include <cstdint>
 
 /** \file SkFixed.h
 
@@ -86,7 +87,6 @@ static inline SkFixed SkFixedFloorToFixed(SkFixed x) {
     return (SkFixed)( (uint32_t)x & 0xFFFF0000 );
 }
 
-#define SkFixedAbs(x)       SkAbs32(x)
 #define SkFixedAve(a, b)    (((a) + (b)) >> 1)
 
 // The divide may exceed 32 bits. Clamp to a signed 32 bit result.
@@ -102,6 +102,8 @@ static inline SkFixed SkFixedMul(SkFixed a, SkFixed b) {
 
 // The VCVT float-to-fixed instruction is part of the VFPv3 instruction set.
 #if defined(__ARM_VFPV3__)
+    #include <cstring>
+
     /* This does not handle NaN or other obscurities, but is faster than
        than (int)(x*65536).  When built on Android with -Os, needs forcing
        to inline or we lose the speed benefit.
@@ -110,7 +112,7 @@ static inline SkFixed SkFixedMul(SkFixed a, SkFixed b) {
     {
         int32_t y;
         asm("vcvt.s32.f32 %0, %0, #16": "+w"(x));
-        memcpy(&y, &x, sizeof(y));
+        std::memcpy(&y, &x, sizeof(y));
         return y;
     }
     #undef SkFloatToFixed

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

@@ -8,10 +8,9 @@
 #ifndef SkFloatBits_DEFINED
 #define SkFloatBits_DEFINED
 
-#include "include/core/SkTypes.h"
-#include "include/private/SkSafe_math.h"
+#include "include/private/base/SkMath.h"
 
-#include <float.h>
+#include <cstdint>
 
 /** Convert a sign-bit int (i.e. float interpreted as int) into a 2s compliement
     int. This also converts -0 (0x80000000) to 0. Doing this to a float allows

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

@@ -8,14 +8,14 @@
 #ifndef SkFloatingPoint_DEFINED
 #define SkFloatingPoint_DEFINED
 
-#include "include/core/SkTypes.h"
-#include "include/private/SkFloatBits.h"
-#include "include/private/SkSafe_math.h"
-#include <float.h>
-#include <math.h>
+#include "include/private/base/SkAttributes.h"
+#include "include/private/base/SkFloatBits.h"
+#include "include/private/base/SkMath.h"
+
+#include <cfloat>
 #include <cmath>
+#include <cstdint>
 #include <cstring>
-#include <limits>
 
 constexpr float SK_FloatSqrt2 = 1.41421356f;
 constexpr float SK_FloatPI    = 3.14159265f;
@@ -150,7 +150,7 @@ static inline int64_t sk_float_saturate2int64(float x) {
 // Cast double to float, ignoring any warning about too-large finite values being cast to float.
 // Clang thinks this is undefined, but it's actually implementation defined to return either
 // the largest float or infinity (one of the two bracketing representable floats).  Good enough!
-SK_ATTRIBUTE(no_sanitize("float-cast-overflow"))
+SK_NO_SANITIZE("float-cast-overflow")
 static inline float sk_double_to_float(double x) {
     return static_cast<float>(x);
 }
@@ -196,12 +196,12 @@ static inline int sk_float_nextlog2(float x) {
 // IEEE defines how float divide behaves for non-finite values and zero-denoms, but C does not
 // so we have a helper that suppresses the possible undefined-behavior warnings.
 
-SK_ATTRIBUTE(no_sanitize("float-divide-by-zero"))
+SK_NO_SANITIZE("float-divide-by-zero")
 static inline float sk_ieee_float_divide(float numer, float denom) {
     return numer / denom;
 }
 
-SK_ATTRIBUTE(no_sanitize("float-divide-by-zero"))
+SK_NO_SANITIZE("float-divide-by-zero")
 static inline double sk_ieee_double_divide(double numer, double denom) {
     return numer / denom;
 }
@@ -219,4 +219,13 @@ static inline float sk_fmaf(float f, float m, float a) {
 #endif
 }
 
+// Returns true iff the provided number is within a small epsilon of 0.
+bool sk_double_nearly_zero(double a);
+
+// Comparing floating point numbers is complicated. This helper only works if one or none
+// of the two inputs is not very close to zero. It also does not work if both inputs could be NaN.
+// The term "ulps" stands for "units of least precision". Read the following for more nuance:
+//   https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+bool sk_doubles_nearly_equal_ulps(double a, double b, uint8_t max_ulps_diff=16);
+
 #endif

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

@@ -0,0 +1,63 @@
+/*
+ * 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 SK_USER_CONFIG_WAS_LOADED
+
+// Include this to set reasonable defaults (e.g. for SK_CPU_LENDIAN)
+#include "include/private/base/SkFeatures.h"
+
+// Allows embedders that want to disable macros that take arguments to just
+// define that symbol to be one of these
+#define SK_NOTHING_ARG1(arg1)
+#define SK_NOTHING_ARG2(arg1, arg2)
+#define SK_NOTHING_ARG3(arg1, arg2, arg3)
+
+// IWYU pragma: begin_exports
+
+// Note: SK_USER_CONFIG_HEADER will not work with Bazel builds and some C++ compilers.
+#if defined(SK_USER_CONFIG_HEADER)
+    #include SK_USER_CONFIG_HEADER
+#elif defined(SK_USE_BAZEL_CONFIG_HEADER)
+    // The Bazel config file is presumed to be in the root directory of its Bazel Workspace.
+    // This is achieved in Skia by having a nested WORKSPACE in include/config and a cc_library
+    // defined in that folder. As a result, we do not try to include SkUserConfig.h from the
+    // top of Skia because Bazel sandboxing will move it to a different location.
+    #include "SkUserConfig.h"
+#else
+    #include "include/config/SkUserConfig.h"
+#endif
+// IWYU pragma: end_exports
+
+// Checks to make sure the SkUserConfig options do not conflict.
+#if !defined(SK_DEBUG) && !defined(SK_RELEASE)
+    #ifdef NDEBUG
+        #define SK_RELEASE
+    #else
+        #define SK_DEBUG
+    #endif
+#endif
+
+#if defined(SK_DEBUG) && defined(SK_RELEASE)
+#  error "cannot define both SK_DEBUG and SK_RELEASE"
+#elif !defined(SK_DEBUG) && !defined(SK_RELEASE)
+#  error "must define either SK_DEBUG or SK_RELEASE"
+#endif
+
+#if defined(SK_CPU_LENDIAN) && defined(SK_CPU_BENDIAN)
+#  error "cannot define both SK_CPU_LENDIAN and SK_CPU_BENDIAN"
+#elif !defined(SK_CPU_LENDIAN) && !defined(SK_CPU_BENDIAN)
+#  error "must define either SK_CPU_LENDIAN or SK_CPU_BENDIAN"
+#endif
+
+#if defined(SK_CPU_BENDIAN) && !defined(I_ACKNOWLEDGE_SKIA_DOES_NOT_SUPPORT_BIG_ENDIAN)
+    #error "The Skia team is not endian-savvy enough to support big-endian CPUs."
+    #error "If you still want to use Skia,"
+    #error "please define I_ACKNOWLEDGE_SKIA_DOES_NOT_SUPPORT_BIG_ENDIAN."
+#endif
+
+#define SK_USER_CONFIG_WAS_LOADED
+#endif // SK_USER_CONFIG_WAS_LOADED

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

@@ -7,8 +7,6 @@
 #ifndef SkMacros_DEFINED
 #define SkMacros_DEFINED
 
-#include <type_traits>
-
 /*
  *  Usage:  SK_MACRO_CONCAT(a, b)   to construct the symbol ab
  *
@@ -40,6 +38,23 @@
     #define SK_END_REQUIRE_DENSE
 #endif
 
+#if defined(__clang__) && defined(__has_feature)
+    // Some compilers have a preprocessor that does not appear to do short-circuit
+    // evaluation as expected
+    #if __has_feature(leak_sanitizer) || __has_feature(address_sanitizer)
+        // Chrome had issues if we tried to include lsan_interface.h ourselves.
+        // https://github.com/llvm/llvm-project/blob/10a35632d55bb05004fe3d0c2d4432bb74897ee7/compiler-rt/include/sanitizer/lsan_interface.h#L26
+extern "C" {
+        void __lsan_ignore_object(const void *p);
+}
+        #define SK_INTENTIONALLY_LEAKED(X) __lsan_ignore_object(X)
+    #else
+        #define SK_INTENTIONALLY_LEAKED(X) ((void)0)
+    #endif
+#else
+    #define SK_INTENTIONALLY_LEAKED(X) ((void)0)
+#endif
+
 #define SK_INIT_TO_AVOID_WARNING    = 0
 
 ////////////////////////////////////////////////////////////////////////////////

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

@@ -8,10 +8,9 @@
 #ifndef SkMalloc_DEFINED
 #define SkMalloc_DEFINED
 
-#include <cstddef>
 #include <cstring>
 
-#include "include/core/SkTypes.h"
+#include "include/private/base/SkAPI.h"
 
 /*
     memory wrappers to be implemented by the porting layer (platform)
@@ -51,7 +50,9 @@ enum {
 SK_API extern void* sk_malloc_flags(size_t size, unsigned flags);
 
 /** Same as standard realloc(), but this one never returns null on failure. It will throw
- *  an exception if it fails.
+ *  if it fails.
+ *  If size is 0, it will call sk_free on buffer and return null. (This behavior is implementation-
+ *  defined for normal realloc. We follow what glibc does.)
  */
 SK_API extern void* sk_realloc_throw(void* buffer, size_t size);
 
@@ -78,10 +79,6 @@ SK_API extern void* sk_calloc_throw(size_t count, size_t elemSize);
 SK_API extern void* sk_malloc_throw(size_t count, size_t elemSize);
 SK_API extern void* sk_realloc_throw(void* buffer, size_t count, size_t elemSize);
 
-// Returns the true usable size provided by the underlying allocator, or 0 if
-// querying the allocation size is not supported.
-SK_API extern size_t sk_malloc_usable_size(void* buffer);
-
 /**
  *  These variants return nullptr on failure
  */

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

@@ -8,7 +8,22 @@
 #ifndef SkMath_DEFINED
 #define SkMath_DEFINED
 
-#include "include/core/SkTypes.h"
+#include "include/private/base/SkAssert.h"
+#include "include/private/base/SkCPUTypes.h"
+
+#include <cstdint>
+#include <climits>
+
+// Max Signed 16 bit value
+static constexpr int16_t SK_MaxS16 = INT16_MAX;
+static constexpr int16_t SK_MinS16 = -SK_MaxS16;
+
+static constexpr int32_t SK_MaxS32 = INT32_MAX;
+static constexpr int32_t SK_MinS32 = -SK_MaxS32;
+static constexpr int32_t SK_NaN32  = INT32_MIN;
+
+static constexpr int64_t SK_MaxS64 = INT64_MAX;
+static constexpr int64_t SK_MinS64 = -SK_MaxS64;
 
 // 64bit -> 32bit utilities
 
@@ -19,6 +34,14 @@ static inline int64_t sk_64_mul(int64_t a, int64_t b) {
     return a * b;
 }
 
+static inline constexpr int32_t SkLeftShift(int32_t value, int32_t shift) {
+    return (int32_t) ((uint32_t) value << shift);
+}
+
+static inline constexpr int64_t SkLeftShift(int64_t value, int32_t shift) {
+    return (int64_t) ((uint64_t) value << shift);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
@@ -48,7 +71,7 @@ static inline unsigned SkMul16ShiftRound(U16CPU a, U16CPU b, int shift) {
  *  Only valid if a and b are unsigned and <= 32767.
  */
 static inline U8CPU SkMulDiv255Round(U16CPU a, U16CPU b) {
-    return SkMul16ShiftRound(a,b,8);
+    return SkMul16ShiftRound(a, b, 8);
 }
 
 #endif

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

@@ -8,11 +8,11 @@
 #ifndef SkMutex_DEFINED
 #define SkMutex_DEFINED
 
-#include "include/core/SkTypes.h"
-#include "include/private/SkMacros.h"
-#include "include/private/SkSemaphore.h"
-#include "include/private/SkThreadAnnotations.h"
-#include "include/private/SkThreadID.h"
+#include "include/private/base/SkAssert.h"
+#include "include/private/base/SkDebug.h"
+#include "include/private/base/SkSemaphore.h"
+#include "include/private/base/SkThreadAnnotations.h"
+#include "include/private/base/SkThreadID.h"
 
 class SK_CAPABILITY("mutex") SkMutex {
 public:

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

@@ -8,9 +8,9 @@
 #ifndef SkNoncopyable_DEFINED
 #define SkNoncopyable_DEFINED
 
-#include "include/core/SkTypes.h"
+#include "include/private/base/SkAPI.h"
 
-/** \class SkNoncopyable
+/** \class SkNoncopyable (DEPRECATED)
 
     SkNoncopyable is the base class for objects that do not want to
     be copied. It hides its copy-constructor and its assignment-operator.

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

@@ -8,8 +8,10 @@
 #ifndef SkOnce_DEFINED
 #define SkOnce_DEFINED
 
-#include "include/private/SkThreadAnnotations.h"
+#include "include/private/base/SkThreadAnnotations.h"
+
 #include <atomic>
+#include <cstdint>
 #include <utility>
 
 // SkOnce provides call-once guarantees for Skia, much like std::once_flag/std::call_once().

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

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ * This file contains private enums related to paths. See also skbug.com/10670
+ */
+
+#ifndef SkPathEnums_DEFINED
+#define SkPathEnums_DEFINED
+
+enum class SkPathConvexity {
+    kConvex,
+    kConcave,
+    kUnknown,
+};
+
+enum class SkPathFirstDirection {
+    kCW,         // == SkPathDirection::kCW
+    kCCW,        // == SkPathDirection::kCCW
+    kUnknown,
+};
+
+#endif

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

@@ -8,7 +8,10 @@
 #ifndef SkSafe32_DEFINED
 #define SkSafe32_DEFINED
 
-#include "include/core/SkTypes.h"
+#include "include/private/base/SkAssert.h"
+#include "include/private/base/SkMath.h"
+
+#include <cstdint>
 
 static constexpr int32_t Sk64_pin_to_s32(int64_t x) {
     return x < SK_MinS32 ? SK_MinS32 : (x > SK_MaxS32 ? SK_MaxS32 : (int32_t)x);
@@ -31,4 +34,16 @@ static constexpr int32_t Sk32_can_overflow_sub(int32_t a, int32_t b) {
     return (int32_t)((uint32_t)a - (uint32_t)b);
 }
 
+/**
+ * This is a 'safe' abs for 32-bit integers that asserts when undefined behavior would occur.
+ * SkTAbs (in SkTemplates.h) is a general purpose absolute-value function.
+ */
+static inline int32_t SkAbs32(int32_t value) {
+    SkASSERT(value != SK_NaN32);  // The most negative int32_t can't be negated.
+    if (value < 0) {
+        value = -value;
+    }
+    return value;
+}
+
 #endif

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

@@ -8,9 +8,10 @@
 #ifndef SkSemaphore_DEFINED
 #define SkSemaphore_DEFINED
 
-#include "include/core/SkTypes.h"
-#include "include/private/SkOnce.h"
-#include "include/private/SkThreadAnnotations.h"
+#include "include/private/base/SkAPI.h"
+#include "include/private/base/SkOnce.h"
+#include "include/private/base/SkThreadAnnotations.h"
+
 #include <algorithm>
 #include <atomic>