@shopify/react-native-skia 2.5.5 → 2.6.1

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

@@ -9,6 +9,8 @@
 
 // Include this to set reasonable defaults (e.g. for SK_CPU_LENDIAN)
 #include "include/private/base/SkFeatures.h"
+// Include this so that users can define the lowest active log priority in their config
+#include "include/private/base/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
@@ -17,7 +19,6 @@
 #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

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

@@ -0,0 +1,68 @@
+/*
+ * 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/base/SkAPI.h"
+#include "include/private/base/SkAttributes.h"
+#include "include/private/base/SkLoadUserConfig.h" // IWYU pragma: keep
+#include "include/private/base/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) {           \
+            if constexpr (priority == SkLogPriority::kFatal) {                 \
+                SK_ABORT("[skia] " fmt, ##__VA_ARGS__);                        \
+            }                                                                  \
+            else {                                                             \
+                SkLog(priority, "[skia] " fmt "\n", ##__VA_ARGS__);            \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+
+#define SKIA_LOG_F(fmt, ...) SKIA_LOG(SkLogPriority::kFatal, "** ERROR ** " fmt, ##__VA_ARGS__)
+#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/cpp/skia/include/private/base/SkLogPriority.h

@@ -0,0 +1,35 @@
+/*
+ * 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 {
+    kFatal = 0,
+    kError = 1,
+    kWarning = 2,
+    kInfo = 3,
+    kDebug = 4,
+};
+
+#endif // SkLogPriority_DEFINED

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

@@ -28,6 +28,15 @@
 
 #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.

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

@@ -595,7 +595,7 @@ private:
 
     void poison() {
 #ifdef SK_SANITIZE_ADDRESS
-        if (fData && fCapacity > fSize) {
+        if (fData && fCapacity > SkToUInt(fSize)) {
             // SkDebugf("  POISONING %p : %zu -> %zu\n", fData, Bytes(fSize), Bytes(fCapacity));
             sk_asan_poison_memory_region(this->end(), Bytes(fCapacity - fSize));
             fPoisoned = true;

package/cpp/skia/include/private/gpu/ganesh/GrD3DTypesMinimal.h

@@ -13,6 +13,7 @@
 #include "include/core/SkRefCnt.h"
 
 #include <dxgiformat.h>
+#include <memory>
 
 #include "include/gpu/ganesh/GrTypes.h"
 
@@ -31,19 +32,18 @@ struct GrD3DFenceInfo;
 // track the current D3D12_RESOURCE_STATES which can be shared with an internal GrD3DTextureResource
 // so that state updates can be seen by all users of the texture.
 struct GrD3DBackendSurfaceInfo {
-    GrD3DBackendSurfaceInfo(const GrD3DTextureResourceInfo& info, GrD3DResourceState* state);
+    GrD3DBackendSurfaceInfo(const GrD3DTextureResourceInfo& info, sk_sp<GrD3DResourceState> state);
+    ~GrD3DBackendSurfaceInfo();
 
-    void cleanup();
+    GrD3DBackendSurfaceInfo(const GrD3DBackendSurfaceInfo&);
+    GrD3DBackendSurfaceInfo& operator=(const GrD3DBackendSurfaceInfo&);
 
-    GrD3DBackendSurfaceInfo& operator=(const GrD3DBackendSurfaceInfo&) = delete;
-
-    // Assigns the passed in GrD3DBackendSurfaceInfo to this object. if isValid is true we will also
-    // attempt to unref the old fLayout on this object.
-    void assign(const GrD3DBackendSurfaceInfo&, bool isValid);
+    GrD3DBackendSurfaceInfo(GrD3DBackendSurfaceInfo&&);
+    GrD3DBackendSurfaceInfo& operator=(GrD3DBackendSurfaceInfo&&);
 
     void setResourceState(GrD3DResourceStateEnum state);
 
-    sk_sp<GrD3DResourceState> getGrD3DResourceState() const;
+    sk_sp<GrD3DResourceState> getResourceState() const;
 
     GrD3DTextureResourceInfo snapTextureResourceInfo() const;
 
@@ -53,22 +53,8 @@ struct GrD3DBackendSurfaceInfo {
 #endif
 
 private:
-    GrD3DTextureResourceInfo* fTextureResourceInfo;
-    GrD3DResourceState* fResourceState;
-};
-
-struct GrD3DTextureResourceSpecHolder {
-public:
-    GrD3DTextureResourceSpecHolder(const GrD3DSurfaceInfo&);
-
-    void cleanup();
-
-    GrD3DSurfaceInfo getSurfaceInfo(uint32_t sampleCount,
-                                    uint32_t levelCount,
-                                    skgpu::Protected isProtected) const;
-
-private:
-    GrD3DTextureResourceSpec* fSpec;
+    std::unique_ptr<GrD3DTextureResourceInfo> fTextureResourceInfo;
+    sk_sp<GrD3DResourceState> fResourceState;
 };
 
 #endif

package/cpp/skia/include/utils/SkEventTracer.h

@@ -28,15 +28,13 @@ public:
     /**
      * If this is the first call to SetInstance or GetInstance then the passed instance is
      * installed and true is returned. Otherwise, false is returned. In either case ownership of the
-     * tracer is transferred and it will be deleted when no longer needed.
+     * tracer is transferred.
      *
-     * Not deleting the tracer on process exit should not cause problems as
-     * the whole heap is about to go away with the process. This can also
-     * improve performance by reducing the amount of work needed.
-     *
-     * @param leakTracer Do not delete tracer on process exit.
+     * On failure, the tracer is deleted; on success the tracer will be held until process exit, and
+     * will not have its destructor run. This avoids race conditions when using Skia from multiple
+     * threads in the midst of application teardown.
      */
-    static bool SetInstance(SkEventTracer*, bool leakTracer = false);
+    static bool SetInstance(SkEventTracer*);
 
     /**
      * Gets the event tracer. If this is the first call to SetInstance or GetIntance then a default

package/cpp/skia/modules/skottie/include/TextShaper.h

@@ -185,13 +185,6 @@ public:
     static Result Shape(const SkString& text, const TextDesc& desc, const SkRect& box,
                         const sk_sp<SkFontMgr>&, const sk_sp<SkShapers::Factory>&);
 
-#if !defined(SK_DISABLE_LEGACY_SHAPER_FACTORY)
-    static Result Shape(const SkString& text, const TextDesc& desc, const SkPoint& point,
-                        const sk_sp<SkFontMgr>&);
-    static Result Shape(const SkString& text, const TextDesc& desc, const SkRect& box,
-                        const sk_sp<SkFontMgr>&);
-#endif
-
 private:
     Shaper() = delete;
 };

package/cpp/skia/modules/skparagraph/include/FontCollection.h

@@ -11,7 +11,6 @@
 #include "modules/skparagraph/include/FontArguments.h"
 #include "modules/skparagraph/include/ParagraphCache.h"
 #include "modules/skparagraph/include/TextStyle.h"
-#include "src/core/SkTHash.h"
 
 namespace skia {
 namespace textlayout {
@@ -21,6 +20,7 @@ class Paragraph;
 class FontCollection : public SkRefCnt {
 public:
     FontCollection();
+    ~FontCollection() override;
 
     size_t getFontManagersCount() const;
 
@@ -36,7 +36,9 @@ public:
     std::vector<sk_sp<SkTypeface>> findTypefaces(const std::vector<SkString>& familyNames, SkFontStyle fontStyle);
     std::vector<sk_sp<SkTypeface>> findTypefaces(const std::vector<SkString>& familyNames, SkFontStyle fontStyle, const std::optional<FontArguments>& fontArgs);
 
-    sk_sp<SkTypeface> defaultFallback(SkUnichar unicode, SkFontStyle fontStyle, const SkString& locale, const std::optional<FontArguments>& fontArgs);
+    sk_sp<SkTypeface> defaultFallback(SkUnichar unicode, const std::vector<SkString>& families,
+                                      SkFontStyle fontStyle, const SkString& locale,
+                                      const std::optional<FontArguments>& fontArgs);
     sk_sp<SkTypeface> defaultEmojiFallback(SkUnichar emojiStart, SkFontStyle fontStyle, const SkString& locale);
     sk_sp<SkTypeface> defaultFallback();
 
@@ -53,25 +55,9 @@ private:
 
     sk_sp<SkTypeface> matchTypeface(const SkString& familyName, SkFontStyle fontStyle);
 
-    struct FamilyKey {
-        FamilyKey(const std::vector<SkString>& familyNames, SkFontStyle style, const std::optional<FontArguments>& args)
-                : fFamilyNames(familyNames), fFontStyle(style), fFontArguments(args) {}
-
-        FamilyKey() {}
-
-        std::vector<SkString> fFamilyNames;
-        SkFontStyle fFontStyle;
-        std::optional<FontArguments> fFontArguments;
-
-        bool operator==(const FamilyKey& other) const;
-
-        struct Hasher {
-            size_t operator()(const FamilyKey& key) const;
-        };
-    };
-
+    struct FaceCache;
+    std::unique_ptr<FaceCache> fFaceCache;
     bool fEnableFontFallback;
-    skia_private::THashMap<FamilyKey, std::vector<sk_sp<SkTypeface>>, FamilyKey::Hasher> fTypefaces;
     sk_sp<SkFontMgr> fDefaultFontManager;
     sk_sp<SkFontMgr> fAssetFontManager;
     sk_sp<SkFontMgr> fDynamicFontManager;

package/cpp/skia/modules/skparagraph/include/ParagraphBuilder.h

@@ -84,15 +84,9 @@ public:
     // been added, but keeping the initial ParagraphStyle.
     virtual void Reset() = 0;
 
-    // Just until we fix all the google3 code
     static std::unique_ptr<ParagraphBuilder> make(const ParagraphStyle& style,
                                                   sk_sp<FontCollection> fontCollection,
                                                   sk_sp<SkUnicode> unicode);
-
-#if !defined(SK_DISABLE_LEGACY_PARAGRAPH_UNICODE)
-    static std::unique_ptr<ParagraphBuilder> make(const ParagraphStyle& style,
-                                                  sk_sp<FontCollection> fontCollection);
-#endif
 };
 }  // namespace textlayout
 }  // namespace skia

package/cpp/skia/modules/skparagraph/include/ParagraphCache.h

@@ -3,7 +3,6 @@
 #define ParagraphCache_DEFINED
 
 #include "include/private/base/SkMutex.h"
-#include "src/core/SkLRUCache.h"
 #include <functional>  // std::function
 
 #define PARAGRAPH_CACHE_STATS
@@ -12,8 +11,6 @@ namespace skia {
 namespace textlayout {
 
 class ParagraphImpl;
-class ParagraphCacheKey;
-class ParagraphCacheValue;
 
 class ParagraphCache {
 public:
@@ -30,8 +27,8 @@ public:
         fChecker = std::move(checker);
     }
     void printStatistics();
-    void turnOn(bool value) { fCacheIsOn = value; }
-    int count() { return fLRUCacheMap.count(); }
+    void turnOn(bool value);
+    int count();
 
     bool isPossiblyTextEditing(ParagraphImpl* paragraph);
 
@@ -44,21 +41,9 @@ public:
      mutable SkMutex fParagraphMutex;
      std::function<void(ParagraphImpl* impl, const char*, bool)> fChecker;
 
-    static const int kMaxEntries = 128;
+    struct Cache;
+    std::unique_ptr<Cache> fCache;
 
-    struct KeyHash {
-        uint32_t operator()(const ParagraphCacheKey& key) const;
-    };
-
-    SkLRUCache<ParagraphCacheKey, std::unique_ptr<Entry>, KeyHash> fLRUCacheMap;
-    bool fCacheIsOn;
-    ParagraphCacheValue* fLastCachedValue;
-
-#ifdef PARAGRAPH_CACHE_STATS
-    int fTotalRequests;
-    int fCacheMisses;
-    int fHashMisses; // cache hit but hash table missed
-#endif
 };
 
 }  // namespace textlayout

package/cpp/skia/modules/skparagraph/include/TypefaceFontProvider.h

@@ -7,7 +7,6 @@
 #include "include/core/SkStream.h"
 #include "include/core/SkString.h"
 #include "include/private/base/SkTArray.h"
-#include "src/core/SkTHash.h"
 
 #include <string>
 #include <unordered_map>
@@ -69,8 +68,8 @@ public:
     sk_sp<SkTypeface> onLegacyMakeTypeface(const char[], SkFontStyle) const override;
 
 private:
-    skia_private::THashMap<SkString, sk_sp<TypefaceFontStyleSet>> fRegisteredFamilies;
-    skia_private::TArray<SkString> fFamilyNames;
+    std::unordered_map<std::string, sk_sp<TypefaceFontStyleSet>> fRegisteredFamilies;
+    skia_private::TArray<std::string> fFamilyNames;
 };
 
 }  // namespace textlayout

package/cpp/skia/modules/skunicode/include/SkUnicode_icu.h

@@ -0,0 +1,18 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkUnicode_icu_DEFINED
+#define SkUnicode_icu_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "modules/skunicode/include/SkUnicode.h"
+
+namespace SkUnicodes::ICU {
+SKUNICODE_API sk_sp<SkUnicode> Make();
+}
+
+#endif //SkUnicode_icu_DEFINED

package/cpp/skia/modules/skunicode/include/SkUnicode_libgrapheme.h

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkUnicode_libgrapheme_DEFINED
+#define SkUnicode_libgrapheme_DEFINED
+
+#include "modules/skunicode/include/SkUnicode.h"
+
+#include <memory>
+
+namespace SkUnicodes::Libgrapheme {
+SKUNICODE_API sk_sp<SkUnicode> Make();
+}
+
+#endif

package/cpp/skia/src/base/SkMathPriv.h

@@ -12,9 +12,31 @@
 #include "include/private/base/SkCPUTypes.h"
 #include "include/private/base/SkTemplates.h"
 
+#include <bit>
 #include <cstddef>
 #include <cstdint>
 
+/**
+ * Return the number of leading zero bits.
+ */
+static constexpr int SkCLZ(uint32_t x) {
+    return std::countl_zero<uint32_t>(x);
+}
+
+/**
+ * Return the number of trailing zero bits.
+ */
+static constexpr int SkCTZ(uint32_t x) {
+    return std::countr_zero<uint32_t>(x);
+}
+
+/*
+ * Return the number of set bits (i.e., the population count) in the provided uint32_t.
+ */
+static constexpr int SkPopCount(uint32_t x) {
+    return std::popcount<uint32_t>(x);
+}
+
 /**
  *  Return the integer square root of value, with a bias of bitBias
  */
@@ -123,113 +145,6 @@ static inline unsigned SkDiv255Round(unsigned prod) {
     static inline uint32_t SkBSwap32(uint32_t v) { return __builtin_bswap32(v); }
 #endif
 
-/*
- * Return the number of set bits (i.e., the population count) in the provided uint32_t.
- */
-int SkPopCount_portable(uint32_t n);
-
-#if defined(__GNUC__) || defined(__clang__)
-    static inline int SkPopCount(uint32_t n) {
-        return __builtin_popcount(n);
-    }
-#else
-    static inline int SkPopCount(uint32_t n) {
-        return SkPopCount_portable(n);
-    }
-#endif
-
-/*
- * Return the 0-based index of the nth bit set in target
- * Returns 32 if there is no nth bit set.
- */
-int SkNthSet(uint32_t target, int n);
-
-//! Returns the number of leading zero bits (0...32)
-// From Hacker's Delight 2nd Edition
-constexpr int SkCLZ_portable(uint32_t x) {
-    int n = 32;
-    uint32_t y = x >> 16; if (y != 0) {n -= 16; x = y;}
-             y = x >>  8; if (y != 0) {n -=  8; x = y;}
-             y = x >>  4; if (y != 0) {n -=  4; x = y;}
-             y = x >>  2; if (y != 0) {n -=  2; x = y;}
-             y = x >>  1; if (y != 0) {return n - 2;}
-    return n - static_cast<int>(x);
-}
-
-static_assert(32 == SkCLZ_portable(0));
-static_assert(31 == SkCLZ_portable(1));
-static_assert( 1 == SkCLZ_portable(1 << 30));
-static_assert( 1 == SkCLZ_portable((1 << 30) | (1 << 24) | 1));
-static_assert( 0 == SkCLZ_portable(~0U));
-
-#if defined(SK_BUILD_FOR_WIN)
-    #include <intrin.h>
-
-    static inline int SkCLZ(uint32_t mask) {
-        if (mask) {
-            unsigned long index = 0;
-            _BitScanReverse(&index, mask);
-            // Suppress this bogus /analyze warning. The check for non-zero
-            // guarantees that _BitScanReverse will succeed.
-            #pragma warning(push)
-            #pragma warning(suppress : 6102) // Using 'index' from failed function call
-            return static_cast<int>(index ^ 0x1F);
-            #pragma warning(pop)
-        } else {
-            return 32;
-        }
-    }
-#elif defined(SK_CPU_ARM32) || defined(__GNUC__) || defined(__clang__)
-    static inline int SkCLZ(uint32_t mask) {
-        // __builtin_clz(0) is undefined, so we have to detect that case.
-        return mask ? __builtin_clz(mask) : 32;
-    }
-#else
-    static inline int SkCLZ(uint32_t mask) {
-        return SkCLZ_portable(mask);
-    }
-#endif
-
-//! Returns the number of trailing zero bits (0...32)
-// From Hacker's Delight 2nd Edition
-constexpr int SkCTZ_portable(uint32_t x) {
-    return 32 - SkCLZ_portable(~x & (x - 1));
-}
-
-static_assert(32 == SkCTZ_portable(0));
-static_assert( 0 == SkCTZ_portable(1));
-static_assert(30 == SkCTZ_portable(1 << 30));
-static_assert( 2 == SkCTZ_portable((1 << 30) | (1 << 24) | (1 << 2)));
-static_assert( 0 == SkCTZ_portable(~0U));
-
-#if defined(SK_BUILD_FOR_WIN)
-    #include <intrin.h>
-
-    static inline int SkCTZ(uint32_t mask) {
-        if (mask) {
-            unsigned long index = 0;
-            _BitScanForward(&index, mask);
-            // Suppress this bogus /analyze warning. The check for non-zero
-            // guarantees that _BitScanReverse will succeed.
-            #pragma warning(push)
-            #pragma warning(suppress : 6102) // Using 'index' from failed function call
-            return static_cast<int>(index);
-            #pragma warning(pop)
-        } else {
-            return 32;
-        }
-    }
-#elif defined(SK_CPU_ARM32) || defined(__GNUC__) || defined(__clang__)
-    static inline int SkCTZ(uint32_t mask) {
-        // __builtin_ctz(0) is undefined, so we have to detect that case.
-        return mask ? __builtin_ctz(mask) : 32;
-    }
-#else
-    static inline int SkCTZ(uint32_t mask) {
-        return SkCTZ_portable(mask);
-    }
-#endif
-
 /**
  *  Returns the log2 of the specified value, were that value to be rounded up
  *  to the next power of 2. It is undefined to pass 0. Examples:
@@ -239,16 +154,11 @@ static_assert( 0 == SkCTZ_portable(~0U));
  *  SkNextLog2(4) -> 2
  *  SkNextLog2(5) -> 3
  */
-static inline int SkNextLog2(uint32_t value) {
+static constexpr int SkNextLog2(uint32_t value) {
     SkASSERT(value != 0);
     return 32 - SkCLZ(value - 1);
 }
 
-constexpr int SkNextLog2_portable(uint32_t value) {
-    SkASSERT(value != 0);
-    return 32 - SkCLZ_portable(value - 1);
-}
-
 /**
 *  Returns the log2 of the specified value, were that value to be rounded down
 *  to the previous power of 2. It is undefined to pass 0. Examples:
@@ -258,52 +168,37 @@ constexpr int SkNextLog2_portable(uint32_t value) {
 *  SkPrevLog2(4) -> 2
 *  SkPrevLog2(5) -> 2
 */
-static inline int SkPrevLog2(uint32_t value) {
+static constexpr int SkPrevLog2(uint32_t value) {
     SkASSERT(value != 0);
     return 32 - SkCLZ(value >> 1);
 }
 
-constexpr int SkPrevLog2_portable(uint32_t value) {
-    SkASSERT(value != 0);
-    return 32 - SkCLZ_portable(value >> 1);
-}
-
 /**
  *  Returns the smallest power-of-2 that is >= the specified value. If value
  *  is already a power of 2, then it is returned unchanged. It is undefined
  *  if value is <= 0.
  */
-static inline int SkNextPow2(int value) {
+static constexpr int SkNextPow2(int value) {
     SkASSERT(value > 0);
     return 1 << SkNextLog2(static_cast<uint32_t>(value));
 }
 
-constexpr int SkNextPow2_portable(int value) {
-    SkASSERT(value > 0);
-    return 1 << SkNextLog2_portable(static_cast<uint32_t>(value));
-}
-
 /**
 *  Returns the largest power-of-2 that is <= the specified value. If value
 *  is already a power of 2, then it is returned unchanged. It is undefined
 *  if value is <= 0.
 */
-static inline int SkPrevPow2(int value) {
+static constexpr int SkPrevPow2(int value) {
     SkASSERT(value > 0);
     return 1 << SkPrevLog2(static_cast<uint32_t>(value));
 }
 
-constexpr int SkPrevPow2_portable(int value) {
-    SkASSERT(value > 0);
-    return 1 << SkPrevLog2_portable(static_cast<uint32_t>(value));
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  * Returns the next power of 2 >= n or n if the next power of 2 can't be represented by size_t.
  */
-constexpr size_t SkNextSizePow2(size_t n) {
+static constexpr size_t SkNextSizePow2(size_t n) {
     constexpr int kNumSizeTBits = 8 * sizeof(size_t);
     constexpr size_t kHighBitSet = size_t(1) << (kNumSizeTBits - 1);
 

package/lib/commonjs/animation/functions/interpolatePaths.d.ts

@@ -16,4 +16,4 @@ import type { ExtrapolationType } from "./interpolate";
  * path2.lineTo(0, 100);
  * const path = interpolatePath(0.5, [0, 1], [path1, path2]);
  */
-export declare const interpolatePaths: (value: number, input: number[], outputRange: SkPath[], options?: ExtrapolationType, output?: SkPath) => SkPath;
+export declare const interpolatePaths: (value: number, input: number[], outputRange: SkPath[], options?: ExtrapolationType, _output?: SkPath) => SkPath;