rngine 0.7.2 → 0.8.1

package/shared/skia/include/private/SkLoadUserConfig.h

@@ -0,0 +1,64 @@
+/*
+ * 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/SkFeatures.h"
+// Include this so that users can define the lowest active log priority in their config
+#include "include/private/SkLogPriority.h" // IWYU pragma: keep
+
+// 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"  // NO_G3_REWRITE
+#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/shared/skia/include/private/SkLog.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkLog_DEFINED
+#define SkLog_DEFINED
+
+#include <cstdarg>
+
+#include "include/private/SkAPI.h"
+#include "include/private/SkAttributes.h"
+#include "include/private/SkLoadUserConfig.h" // IWYU pragma: keep
+#include "include/private/SkLogPriority.h"
+
+#if !defined(SkLog)
+// To be implemented per platform.
+void SkLogVAList(SkLogPriority priority, const char format[], va_list args) SK_PRINTF_LIKE(2, 0);
+void SK_SPI SkLog(SkLogPriority priority, const char format[], ...) SK_PRINTF_LIKE(2, 3);
+#endif
+
+/**
+ * TODO (b/469441457): SKGPU_GRAPHITE_LOWEST_ACTIVE_LOG_PRIORITY Was the config used to set the log
+ * priority, so we check for that define as well. Eventually, we should move clients using this
+ * define to the new one.
+ */
+#if defined(SKGPU_GRAPHITE_LOWEST_ACTIVE_LOG_PRIORITY)
+    static constexpr SkLogPriority MapGraphitePriority(skgpu::graphite::LogPriority priority) {
+        switch (priority) {
+            case skgpu::graphite::LogPriority::kError:   return SkLogPriority::kError;
+            case skgpu::graphite::LogPriority::kWarning: return SkLogPriority::kWarning;
+            case skgpu::graphite::LogPriority::kInfo:    return SkLogPriority::kInfo;
+            case skgpu::graphite::LogPriority::kDebug:   return SkLogPriority::kDebug;
+            default: return SkLogPriority::kDebug;
+        }
+    }
+    #define SKIA_LOWEST_ACTIVE_LOG_PRIORITY MapGraphitePriority(SKGPU_GRAPHITE_LOWEST_ACTIVE_LOG_PRIORITY)
+#endif
+
+#if !defined(SKIA_LOWEST_ACTIVE_LOG_PRIORITY)
+#ifdef SK_DEBUG
+    #define SKIA_LOWEST_ACTIVE_LOG_PRIORITY SkLogPriority::kDebug
+#else
+    #define SKIA_LOWEST_ACTIVE_LOG_PRIORITY SkLogPriority::kInfo
+#endif
+#endif
+
+#define SKIA_LOG(priority, fmt, ...)                                           \
+    do {                                                                       \
+        if constexpr (priority <= SKIA_LOWEST_ACTIVE_LOG_PRIORITY) {           \
+            SkLog(priority, "[skia] " fmt "\n", ##__VA_ARGS__);                \
+        }                                                                      \
+    } while (0)
+
+#define SKIA_LOG_E(fmt, ...) SKIA_LOG(SkLogPriority::kError, "** ERROR ** " fmt, ##__VA_ARGS__)
+#define SKIA_LOG_W(fmt, ...) SKIA_LOG(SkLogPriority::kWarning, "WARNING - " fmt, ##__VA_ARGS__)
+#define SKIA_LOG_I(fmt, ...) SKIA_LOG(SkLogPriority::kInfo, fmt, ##__VA_ARGS__)
+#define SKIA_LOG_D(fmt, ...) SKIA_LOG(SkLogPriority::kDebug, fmt, ##__VA_ARGS__)
+
+#endif // SkLog_DEFINED

package/shared/skia/include/private/SkLogPriority.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkLogPriority_DEFINED
+#define SkLogPriority_DEFINED
+
+/**
+ * Note: this file may be included in clients' SkUserConfig.h files, so including any other headers
+ * in this file should be avoided.
+ */
+
+/**
+ * SKIA_LOWEST_ACTIVE_LOG_PRIORITY can be defined to one of these values (in
+ * SkUserConfig.h) to control Skia's logging behavior.
+ *
+ * For example:
+ * ```
+ * #define SKIA_LOWEST_ACTIVE_LOG_PRIORITY SkLogPriority::kWarning
+ * ```
+ * Would cause Skia to log warnings, non-fatal errors, and fatal errors.
+ * However, debug logs would be omitted.
+ */
+enum class SkLogPriority : int {
+    kError = 0,
+    kWarning = 1,
+    kInfo = 2,
+    kDebug = 3,
+};
+
+#endif // SkLogPriority_DEFINED

package/shared/skia/include/private/SkMacros.h

@@ -0,0 +1,170 @@
+/*
+ * Copyright 2018 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkMacros_DEFINED
+#define SkMacros_DEFINED
+
+#include "include/private/SkTo.h" // IWYU pragma: keep
+
+/*
+ *  Usage:  SK_MACRO_CONCAT(a, b)   to construct the symbol ab
+ *
+ *  SK_MACRO_CONCAT_IMPL_PRIV just exists to make this work. Do not use directly
+ *
+ */
+#define SK_MACRO_CONCAT(X, Y)           SK_MACRO_CONCAT_IMPL_PRIV(X, Y)
+#define SK_MACRO_CONCAT_IMPL_PRIV(X, Y)  X ## Y
+
+/*
+ *  Usage: SK_MACRO_APPEND_LINE(foo)    to make foo123, where 123 is the current
+ *                                      line number. Easy way to construct
+ *                                      unique names for local functions or
+ *                                      variables.
+ */
+#define SK_MACRO_APPEND_LINE(name)  SK_MACRO_CONCAT(name, __LINE__)
+
+#define SK_MACRO_APPEND_COUNTER(name) SK_MACRO_CONCAT(name, __COUNTER__)
+
+/*
+ *  Makes a string of X, where X is expanded before conversion to a string if X itself contains
+ *  macros.
+ *
+ *  Usage: SK_MACRO_STRINGIFY(__LINE__)    to make "123", where 123 is the current line number.
+ */
+#define SK_MACRO_STRINGIFY(X) SK_MACRO_STRINGIFY_IMPL_PRIV(X)
+#define SK_MACRO_STRINGIFY_IMPL_PRIV(X) #X
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Can be used to bracket data types that must be dense/packed, e.g. hash keys.
+#if defined(__clang__)  // This should work on GCC too, but GCC diagnostic pop didn't seem to work!
+    #define SK_BEGIN_REQUIRE_DENSE _Pragma("GCC diagnostic push") \
+                                   _Pragma("GCC diagnostic error \"-Wpadded\"")
+    #define SK_END_REQUIRE_DENSE   _Pragma("GCC diagnostic pop")
+#else
+    #define SK_BEGIN_REQUIRE_DENSE
+    #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
+
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Defines overloaded bitwise operators to make it easier to use an enum as a
+ * bitfield.
+ */
+#define SK_MAKE_BITFIELD_OPS(X) \
+    inline X operator ~(X a) { \
+        using U = std::underlying_type_t<X>; \
+        return (X) (~static_cast<U>(a)); \
+    } \
+    inline X operator |(X a, X b) { \
+        using U = std::underlying_type_t<X>; \
+        return (X) (static_cast<U>(a) | static_cast<U>(b)); \
+    } \
+    inline X& operator |=(X& a, X b) { \
+        return (a = a | b); \
+    } \
+    inline X operator &(X a, X b) { \
+        using U = std::underlying_type_t<X>; \
+        return (X) (static_cast<U>(a) & static_cast<U>(b)); \
+    } \
+    inline X& operator &=(X& a, X b) { \
+        return (a = a & b); \
+    }
+
+#define SK_DECL_BITFIELD_OPS_FRIENDS(X) \
+    friend X operator ~(X a); \
+    friend X operator |(X a, X b); \
+    friend X& operator |=(X& a, X b); \
+    \
+    friend X operator &(X a, X b); \
+    friend X& operator &=(X& a, X b);
+
+/**
+ * Wraps a C++11 enum that we use as a bitfield, and enables a limited amount of
+ * masking with type safety. Instantiated with the ~ operator.
+ */
+template<typename TFlags> class SkTFlagsMask {
+public:
+    constexpr explicit SkTFlagsMask(TFlags value) : SkTFlagsMask(static_cast<int>(value)) {}
+    constexpr explicit SkTFlagsMask(int value) : fValue(value) {}
+    constexpr int value() const { return fValue; }
+private:
+    const int fValue;
+};
+
+/**
+ * Defines bitwise operators that make it possible to use an enum class as a
+ * basic bitfield.
+ */
+#define SK_MAKE_BITFIELD_CLASS_OPS(X) \
+    [[maybe_unused]] constexpr SkTFlagsMask<X> operator~(X a) { \
+        return SkTFlagsMask<X>(~static_cast<int>(a)); \
+    } \
+    [[maybe_unused]] constexpr X operator|(X a, X b) { \
+        return static_cast<X>(static_cast<int>(a) | static_cast<int>(b)); \
+    } \
+    [[maybe_unused]] inline X& operator|=(X& a, X b) { \
+        return (a = a | b); \
+    } \
+    [[maybe_unused]] constexpr bool operator&(X a, X b) { \
+        return SkToBool(static_cast<int>(a) & static_cast<int>(b)); \
+    } \
+    [[maybe_unused]] constexpr SkTFlagsMask<X> operator|(SkTFlagsMask<X> a, SkTFlagsMask<X> b) { \
+        return SkTFlagsMask<X>(a.value() | b.value()); \
+    } \
+    [[maybe_unused]] constexpr SkTFlagsMask<X> operator|(SkTFlagsMask<X> a, X b) { \
+        return SkTFlagsMask<X>(a.value() | static_cast<int>(b)); \
+    } \
+    [[maybe_unused]] constexpr SkTFlagsMask<X> operator|(X a, SkTFlagsMask<X> b) { \
+        return SkTFlagsMask<X>(static_cast<int>(a) | b.value()); \
+    } \
+    [[maybe_unused]] constexpr X operator&(SkTFlagsMask<X> a, SkTFlagsMask<X> b) { \
+        return static_cast<X>(a.value() & b.value()); \
+    } \
+    [[maybe_unused]] constexpr X operator&(SkTFlagsMask<X> a, X b) { \
+        return static_cast<X>(a.value() & static_cast<int>(b)); \
+    } \
+    [[maybe_unused]] constexpr X operator&(X a, SkTFlagsMask<X> b) { \
+        return static_cast<X>(static_cast<int>(a) & b.value()); \
+    } \
+    [[maybe_unused]] inline X& operator&=(X& a, SkTFlagsMask<X> b) { \
+        return (a = a & b); \
+    } \
+
+#define SK_DECL_BITFIELD_CLASS_OPS_FRIENDS(X) \
+    friend constexpr SkTFlagsMask<X> operator ~(X); \
+    friend constexpr X operator |(X, X); \
+    friend X& operator |=(X&, X); \
+    friend constexpr bool operator &(X, X); \
+    friend constexpr SkTFlagsMask<X> operator|(SkTFlagsMask<X>, SkTFlagsMask<X>); \
+    friend constexpr SkTFlagsMask<X> operator|(SkTFlagsMask<X>, X); \
+    friend constexpr SkTFlagsMask<X> operator|(X, SkTFlagsMask<X>); \
+    friend constexpr X operator&(SkTFlagsMask<X>, SkTFlagsMask<X>); \
+    friend constexpr X operator&(SkTFlagsMask<X>, X); \
+    friend constexpr X operator&(X, SkTFlagsMask<X>); \
+    friend X& operator &=(X&, SkTFlagsMask<X>)
+
+#endif  // SkMacros_DEFINED

package/shared/skia/include/private/SkMalloc.h

@@ -0,0 +1,152 @@
+/*
+ * Copyright 2017 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkMalloc_DEFINED
+#define SkMalloc_DEFINED
+
+#include <cstring>
+
+#include "include/private/SkAPI.h"
+
+/*
+    memory wrappers to be implemented by the porting layer (platform)
+*/
+
+
+/** Free memory returned by sk_malloc(). It is safe to pass null. */
+SK_API extern void sk_free(void*);
+
+/**
+ *  Called internally if we run out of memory. The platform implementation must
+ *  not return, but should either throw an exception or otherwise exit.
+ */
+SK_API extern void sk_out_of_memory(void);
+
+enum {
+    /**
+     *  If this bit is set, the returned buffer must be zero-initialized. If this bit is not set
+     *  the buffer can be uninitialized.
+     */
+    SK_MALLOC_ZERO_INITIALIZE   = 1 << 0,
+
+    /**
+     *  If this bit is set, the implementation must throw/crash/quit if the request cannot
+     *  be fulfilled. If this bit is not set, then it should return nullptr on failure.
+     */
+    SK_MALLOC_THROW             = 1 << 1,
+};
+/**
+ *  Return a block of memory (at least 4-byte aligned) of at least the specified size.
+ *  If the requested memory cannot be returned, either return nullptr or throw/exit, depending
+ *  on the SK_MALLOC_THROW bit. If the allocation succeeds, the memory will be zero-initialized
+ *  if the SK_MALLOC_ZERO_INITIALIZE bit was set.
+ *
+ *  To free the memory, call sk_free()
+ */
+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
+ *  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);
+
+/**
+ *  Return the size of the block of memory allocated in reality for a given pointer. The pointer
+ *  passed must have been allocated using the sk_malloc_* or sk_realloc_* functions. The "size"
+ *  parameter indicates the size originally requested when the memory block was allocated, and
+ *  the value returned by this function must be bigger or equal to it.
+ */
+SK_API extern size_t sk_malloc_size(void* addr, size_t size);
+
+static inline void* sk_malloc_throw(size_t size) {
+    return sk_malloc_flags(size, SK_MALLOC_THROW);
+}
+
+static inline void* sk_calloc_throw(size_t size) {
+    return sk_malloc_flags(size, SK_MALLOC_THROW | SK_MALLOC_ZERO_INITIALIZE);
+}
+
+static inline void* sk_calloc_canfail(size_t size) {
+#if defined(SK_BUILD_FOR_FUZZER)
+    // To reduce the chance of OOM, pretend we can't allocate more than 200kb.
+    if (size > 200000) {
+        return nullptr;
+    }
+#endif
+    return sk_malloc_flags(size, SK_MALLOC_ZERO_INITIALIZE);
+}
+
+// Performs a safe multiply count * elemSize, checking for overflow
+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);
+
+/**
+ *  These variants return nullptr on failure
+ */
+static inline void* sk_malloc_canfail(size_t size) {
+#if defined(SK_BUILD_FOR_FUZZER)
+    // To reduce the chance of OOM, pretend we can't allocate more than 200kb.
+    if (size > 200000) {
+        return nullptr;
+    }
+#endif
+    return sk_malloc_flags(size, 0);
+}
+SK_API extern void* sk_malloc_canfail(size_t count, size_t elemSize);
+
+// bzero is safer than memset, but we can't rely on it, so... sk_bzero()
+static inline void sk_bzero(void* buffer, size_t size) {
+    // Please c.f. sk_careful_memcpy.  It's undefined behavior to call memset(null, 0, 0).
+    if (size) {
+        memset(buffer, 0, size);
+    }
+}
+
+/**
+ *  sk_careful_memcpy() is just like memcpy(), but guards against undefined behavior.
+ *
+ * It is undefined behavior to call memcpy() with null dst or src, even if len is 0.
+ * If an optimizer is "smart" enough, it can exploit this to do unexpected things.
+ *     memcpy(dst, src, 0);
+ *     if (src) {
+ *         printf("%x\n", *src);
+ *     }
+ * In this code the compiler can assume src is not null and omit the if (src) {...} check,
+ * unconditionally running the printf, crashing the program if src really is null.
+ * Of the compilers we pay attention to only GCC performs this optimization in practice.
+ */
+static inline void* sk_careful_memcpy(void* dst, const void* src, size_t len) {
+    // When we pass >0 len we had better already be passing valid pointers.
+    // So we just need to skip calling memcpy when len == 0.
+    if (len) {
+        memcpy(dst,src,len);
+    }
+    return dst;
+}
+
+static inline void* sk_careful_memmove(void* dst, const void* src, size_t len) {
+    // When we pass >0 len we had better already be passing valid pointers.
+    // So we just need to skip calling memcpy when len == 0.
+    if (len) {
+        memmove(dst,src,len);
+    }
+    return dst;
+}
+
+static inline int sk_careful_memcmp(const void* a, const void* b, size_t len) {
+    // When we pass >0 len we had better already be passing valid pointers.
+    // So we just need to skip calling memcmp when len == 0.
+    if (len == 0) {
+        return 0;   // we treat zero-length buffers as "equal"
+    }
+    return memcmp(a, b, len);
+}
+
+#endif  // SkMalloc_DEFINED

package/shared/skia/include/private/SkMath.h

@@ -0,0 +1,77 @@
+/*
+ * 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 SkMath_DEFINED
+#define SkMath_DEFINED
+
+#include "include/private/SkAssert.h"
+#include "include/private/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
+
+// Handy util that can be passed two ints, and will automatically promote to
+// 64bits before the multiply, so the caller doesn't have to remember to cast
+// e.g. (int64_t)a * b;
+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);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Returns true if value is a power of 2. Does not explicitly check for
+ *  value <= 0.
+ */
+template <typename T> constexpr inline bool SkIsPow2(T value) {
+    return (value & (value - 1)) == 0;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Return a*b/((1 << shift) - 1), rounding any fractional bits.
+ *  Only valid if a and b are unsigned and <= 32767 and shift is > 0 and <= 8
+ */
+static inline unsigned SkMul16ShiftRound(U16CPU a, U16CPU b, int shift) {
+    SkASSERT(a <= 32767);
+    SkASSERT(b <= 32767);
+    SkASSERT(shift > 0 && shift <= 8);
+    unsigned prod = a*b + (1 << (shift - 1));
+    return (prod + (prod >> shift)) >> shift;
+}
+
+/**
+ *  Return a*b/255, rounding any fractional bits.
+ *  Only valid if a and b are unsigned and <= 32767.
+ */
+static inline U8CPU SkMulDiv255Round(U16CPU a, U16CPU b) {
+    return SkMul16ShiftRound(a, b, 8);
+}
+
+#endif

package/shared/skia/include/private/SkMutex.h

@@ -0,0 +1,72 @@
+/*
+ * 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 SkMutex_DEFINED
+#define SkMutex_DEFINED
+
+#include "include/private/SkAssert.h"
+#include "include/private/SkDebug.h"
+#include "include/private/SkSemaphore.h"
+#include "include/private/SkThreadAnnotations.h"
+#include "include/private/SkThreadID.h"
+
+/**
+ * class SkMutex
+ *
+ * This allows us to have a mutex without needing the one in
+ * the C++ std library which does not work with all clients.
+ * go/cstyle#Disallowed_Stdlib
+ */
+
+class SK_CAPABILITY("mutex") SkMutex {
+public:
+    constexpr SkMutex() = default;
+
+    ~SkMutex() {
+        this->assertNotHeld();
+    }
+
+    void acquire() SK_ACQUIRE() {
+        fSemaphore.wait();
+        SkDEBUGCODE(fOwner = SkGetThreadID();)
+    }
+
+    void release() SK_RELEASE_CAPABILITY() {
+        this->assertHeld();
+        SkDEBUGCODE(fOwner = kIllegalThreadID;)
+        fSemaphore.signal();
+    }
+
+    void assertHeld() SK_ASSERT_CAPABILITY(this) {
+        SkASSERT(fOwner == SkGetThreadID());
+    }
+
+    void assertNotHeld() {
+        SkASSERT(fOwner == kIllegalThreadID);
+    }
+
+private:
+    SkSemaphore fSemaphore{1};
+    SkDEBUGCODE(SkThreadID fOwner{kIllegalThreadID};)
+};
+
+class SK_SCOPED_CAPABILITY SkAutoMutexExclusive {
+public:
+    SkAutoMutexExclusive(SkMutex& mutex) SK_ACQUIRE(mutex) : fMutex(mutex) { fMutex.acquire(); }
+    ~SkAutoMutexExclusive() SK_RELEASE_CAPABILITY() { fMutex.release(); }
+
+    SkAutoMutexExclusive(const SkAutoMutexExclusive&) = delete;
+    SkAutoMutexExclusive(SkAutoMutexExclusive&&) = delete;
+
+    SkAutoMutexExclusive& operator=(const SkAutoMutexExclusive&) = delete;
+    SkAutoMutexExclusive& operator=(SkAutoMutexExclusive&&) = delete;
+
+private:
+    SkMutex& fMutex;
+};
+
+#endif  // SkMutex_DEFINED

package/shared/skia/include/private/SkNoncopyable.h

@@ -0,0 +1,30 @@
+/*
+ * 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 SkNoncopyable_DEFINED
+#define SkNoncopyable_DEFINED
+
+#include "include/private/SkAPI.h"
+
+/** \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.
+*/
+class SK_API SkNoncopyable {
+public:
+    SkNoncopyable() = default;
+
+    SkNoncopyable(SkNoncopyable&&) = default;
+    SkNoncopyable& operator =(SkNoncopyable&&) = default;
+
+private:
+    SkNoncopyable(const SkNoncopyable&) = delete;
+    SkNoncopyable& operator=(const SkNoncopyable&) = delete;
+};
+
+#endif