@shopify/react-native-skia 2.11.0-next.2 → 2.11.0

package/cpp/skia/include/core/SkShader.h

@@ -12,7 +12,7 @@
 #include "include/core/SkColorSpace.h"
 #include "include/core/SkFlattenable.h"
 #include "include/core/SkRefCnt.h"
-#include "include/private/base/SkAPI.h"
+#include "include/private/SkAPI.h"
 
 class SkBlender;
 class SkColorFilter;

package/cpp/skia/include/core/SkSize.h

@@ -9,7 +9,7 @@
 #define SkSize_DEFINED
 
 #include "include/core/SkScalar.h"
-#include "include/private/base/SkTo.h"
+#include "include/private/SkTo.h"
 
 #include <cstdint>
 

package/cpp/skia/include/core/SkSpan.h

@@ -5,9 +5,170 @@
  * found in the LICENSE file.
  */
 
-// We want SkSpan to be a public API, but it is also fundamental to many of our internal types.
-// Thus, we have a public file that clients can include. This file defers to the private copy
-// so we do not have a dependency cycle from our "base" files to our "core" files.
+#ifndef SkSpan_DEFINED
+#define SkSpan_DEFINED
 
-#include "include/private/base/SkSpan_impl.h" // IWYU pragma: export
+/*
+ *  Define this to keep the bespoke SkSpan implementation, until clients are ready.
+ *  When this is not defined, SkSpan becomes just an alias for std::span
+ */
+#define SK_USE_LEGACY_SKSPAN
+
+/*
+ *  SkSpan handles single POD initialization differently from std::span
+ *  This macro allows clients to initialize a span with a single POD that will work with
+ *  either implementation of SkSpan.
+ *
+ *  When we switch to std::span entirely, callsites can remove this macro, and juse type {{a}}
+ */
+#ifdef SK_USE_LEGACY_SKSPAN
+    #define SKSPAN_INIT_ONE(elem)   {elem}
+#else
+    #define SKSPAN_INIT_ONE(elem)   {{elem}}
+#endif
+
+#ifdef SK_USE_LEGACY_SKSPAN
+
+#include "include/private/SkAssert.h"
+#include "include/private/SkTo.h"
+
+#include <cstddef>
+#include <initializer_list>
+#include <iterator>
+#include <limits>
+#include <utility>
+
+// Having this be an export works around IWYU churn related to
+// https://github.com/include-what-you-use/include-what-you-use/issues/1121
+#include <type_traits> // IWYU pragma: export
+
+// Add macro to check the lifetime of initializer_list arguments. initializer_list has a very
+// short life span, and can only be used as a parameter, and not as a variable.
+#if defined(__clang__) && defined(__has_cpp_attribute) && __has_cpp_attribute(clang::lifetimebound)
+#define SK_CHECK_IL_LIFETIME [[clang::lifetimebound]]
+#else
+#define SK_CHECK_IL_LIFETIME
+#endif
+
+/**
+ * SkSpan holds a reference to contiguous data of type T along with a count. SkSpan does not own
+ * the data itself but is merely a reference, therefore you must take care with the lifetime of
+ * the underlying data.
+ *
+ * SkSpan is a count and a pointer into existing array or data type that stores its data in
+ * contiguous memory like std::vector. Any container that works with std::size() and std::data()
+ * can be used.
+ *
+ * SkSpan makes a convenient parameter for a routine to accept array like things. This allows you to
+ * write the routine without overloads for all different container types.
+ *
+ * Example:
+ *     void routine(SkSpan<const int> a) { ... }
+ *
+ *     std::vector v = {1, 2, 3, 4, 5};
+ *
+ *     routine(a);
+ *
+ * A word of caution when working with initializer_list, initializer_lists have a lifetime that is
+ * limited to the current statement. The following is correct and safe:
+ *
+ * Example:
+ *     routine({1,2,3,4,5});
+ *
+ * The following is undefined, and will result in erratic execution:
+ *
+ * Bad Example:
+ *     initializer_list l = {1, 2, 3, 4, 5};   // The data behind l dies at the ;.
+ *     routine(l);
+ */
+template <typename T>
+class SkSpan {
+public:
+    constexpr SkSpan() : fPtr{nullptr}, fSize{0} {}
+
+    template <typename Integer, std::enable_if_t<std::is_integral_v<Integer>, bool> = true>
+    constexpr SkSpan(T* ptr, Integer size) : fPtr{ptr}, fSize{SkToSizeT(size)} {
+        SkASSERT(ptr || fSize == 0);  // disallow nullptr + a nonzero size
+        SkASSERT(fSize < (std::numeric_limits<size_t>::max() / sizeof(T)));
+    }
+    template <typename U, typename = std::enable_if_t<std::is_same_v<const U, T>>>
+    constexpr SkSpan(const SkSpan<U>& that) : fPtr(std::data(that)), fSize(std::size(that)) {}
+    constexpr SkSpan(const SkSpan& o) = default;
+    template<size_t N> constexpr SkSpan(T(&a)[N]) : SkSpan(a, N) { }
+    template<typename Container>
+    constexpr SkSpan(Container&& c) : SkSpan(std::data(c), std::size(c)) { }
+    SkSpan(std::initializer_list<T> il SK_CHECK_IL_LIFETIME)
+            : SkSpan(std::data(il), std::size(il)) {}
+
+    constexpr SkSpan& operator=(const SkSpan& that) = default;
+
+    constexpr T& operator [] (size_t i) const {
+        return fPtr[sk_collection_check_bounds(i, this->size())];
+    }
+    constexpr T& front() const { sk_collection_not_empty(this->empty()); return fPtr[0]; }
+    constexpr T& back()  const { sk_collection_not_empty(this->empty()); return fPtr[fSize - 1]; }
+    constexpr T* begin() const { return fPtr; }
+    constexpr T* end() const { return fPtr + fSize; }
+    constexpr auto rbegin() const { return std::make_reverse_iterator(this->end()); }
+    constexpr auto rend() const { return std::make_reverse_iterator(this->begin()); }
+    constexpr T* data() const { return this->begin(); }
+    constexpr size_t size() const { return fSize; }
+    constexpr bool empty() const { return fSize == 0; }
+    constexpr size_t size_bytes() const { return fSize * sizeof(T); }
+    constexpr SkSpan<T> first(size_t prefixLen) const {
+        return SkSpan{fPtr, sk_collection_check_length(prefixLen, fSize)};
+    }
+    constexpr SkSpan<T> last(size_t postfixLen) const {
+        return SkSpan{fPtr + (this->size() - postfixLen),
+                      sk_collection_check_length(postfixLen, fSize)};
+    }
+    constexpr SkSpan<T> subspan(size_t offset) const {
+        return this->subspan(offset, this->size() - offset);
+    }
+    constexpr SkSpan<T> subspan(size_t offset, size_t count) const {
+        const size_t safeOffset = sk_collection_check_length(offset, fSize);
+
+        // Should read offset + count > size(), but that could overflow. We know that safeOffset
+        // is <= size, therefore the subtraction will not overflow.
+        if (count > this->size() - safeOffset) SK_UNLIKELY {
+            // The count is too large.
+            SkUNREACHABLE;
+        }
+        return SkSpan{fPtr + safeOffset, count};
+    }
+
+private:
+    T* fPtr;
+    size_t fSize;
+};
+
+template <typename Container>
+SkSpan(Container&&) ->
+        SkSpan<std::remove_pointer_t<decltype(std::data(std::declval<Container>()))>>;
+
+#else
+
+#include <span>
+
+template <typename T> using SkSpan = std::span<T>;
+
+#endif  // legacy
+
+// These helper functions are temporary and only meant to be used during the Spanify process
+// to ease the transition from pointers to spans (e.g. replacing `ptr++`).
+// Once the Spanify process is complete, these callsites should be refactored to use
+// more idiomatic span patterns, and these functions should be removed.
+template <typename T>
+constexpr SkSpan<T> SkPreIncrementSpan(SkSpan<T>& s) {
+    s = s.subspan(1);
+    return s;
+}
+
+template <typename T>
+constexpr SkSpan<T> SkPostIncrementSpan(SkSpan<T>& s) {
+    SkSpan<T> old = s;
+    s = s.subspan(1);
+    return old;
+}
 
+#endif  // SkSpan_DEFINED

package/cpp/skia/include/core/SkStream.h

@@ -12,8 +12,8 @@
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkTypes.h"
-#include "include/private/base/SkCPUTypes.h"
-#include "include/private/base/SkTo.h"
+#include "include/private/SkCPUTypes.h"
+#include "include/private/SkTo.h"
 
 #include <cstdint>
 #include <cstdio>

package/cpp/skia/include/core/SkStrikeRef.h

@@ -57,6 +57,22 @@ public:
     */
     SkScalar getWidth(SkGlyphID glyph) const;
 
+    /** Retrieves the advance widths for each glyph, handling arbitrary strides for both
+        input glyphs and output advances.
+
+        @param count              number of glyphs to measure
+        @param first_glyph        pointer to the first glyph ID, glyph is 32-bit, instead
+                                  of SkGlyphID, in preparation for large glyph ids.
+        @param glyph_stride_32    stride in 32-bit words between input glyph IDs
+        @param first_advance      pointer to the first output advance
+        @param advance_stride_32  stride in 32-bit words between output advances
+    */
+    void getWidthsStrided(unsigned count,
+                          const uint32_t* first_glyph,
+                          unsigned glyph_stride_32,
+                          SkScalar* first_advance,
+                          unsigned advance_stride_32) const;
+
     /** Retrieves the advance widths and bounds for each glyph.
         widths receives min(widths.size(), glyphs.size()) values.
         bounds receives min(bounds.size(), glyphs.size()) values.

package/cpp/skia/include/core/SkString.h

@@ -11,8 +11,8 @@
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkTypes.h"
-#include "include/private/base/SkTo.h"
-#include "include/private/base/SkTypeTraits.h"
+#include "include/private/SkTo.h"
+#include "include/private/SkTypeTraits.h"
 
 #include <atomic>
 #include <cstdarg>

package/cpp/skia/include/core/SkStrokeRec.h

@@ -11,7 +11,7 @@
 #include "include/core/SkPaint.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkTypes.h"
-#include "include/private/base/SkMacros.h"
+#include "include/private/SkMacros.h"
 
 #include <cmath>
 #include <cstdint>

package/cpp/skia/include/core/SkSurfaceProps.h

@@ -10,7 +10,7 @@
 
 #include "include/core/SkScalar.h"
 #include "include/core/SkTypes.h"
-#include "include/private/base/SkTo.h"
+#include "include/private/SkTo.h"
 
 /**
  *  Description of how the LCD strips are arranged for each pixel. If this is unknown, or the

package/cpp/skia/include/core/SkSwizzle.h

@@ -8,7 +8,7 @@
 #ifndef SkSwizzle_DEFINED
 #define SkSwizzle_DEFINED
 
-#include "include/private/base/SkAPI.h"
+#include "include/private/SkAPI.h"
 
 #include <cstdint>
 

package/cpp/skia/include/core/SkTextBlob.h

@@ -17,8 +17,8 @@
 #include "include/core/SkScalar.h"
 #include "include/core/SkSpan.h"
 #include "include/core/SkTypes.h"
-#include "include/private/base/SkDebug.h"
-#include "include/private/base/SkTemplates.h"
+#include "include/private/SkDebug.h"
+#include "include/private/SkTemplates.h"
 
 #include <atomic>
 #include <cstdint>

package/cpp/skia/include/core/SkTiledImageUtils.h

@@ -14,7 +14,7 @@
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSamplingOptions.h"
 #include "include/core/SkScalar.h"
-#include "include/private/base/SkAPI.h"
+#include "include/private/SkAPI.h"
 
 #include <cstdint>
 

package/cpp/skia/include/core/SkTypeface.h

@@ -17,8 +17,8 @@
 #include "include/core/SkSpan.h"
 #include "include/core/SkString.h"
 #include "include/core/SkTypes.h"
+#include "include/private/SkOnce.h"
 #include "include/private/SkWeakRefCnt.h"
-#include "include/private/base/SkOnce.h"
 
 #include <cstddef>
 #include <cstdint>
@@ -145,10 +145,16 @@ public:
         of a typeface referring to the same font. If that font is not available,
         return nullptr.
         Goes through all registered typeface factories and lastResortMgr (if non-null).
+        If the sanitizer proc is provided, that will be used on the data extracted from
+        the stream before it is passed on to any underlying decoders.
         Does not affect ownership of SkStream.
      */
 
-    static sk_sp<SkTypeface> MakeDeserialize(SkStream*, sk_sp<SkFontMgr> lastResortMgr);
+    using SkTypefaceStreamSanitizerProc = sk_sp<SkData> (*)(sk_sp<const SkData>);
+
+    static sk_sp<SkTypeface> MakeDeserialize(SkStream*,
+                                             sk_sp<SkFontMgr> lastResortMgr,
+                                             SkTypefaceStreamSanitizerProc = nullptr);
 
     /**
      *  Given an array of UTF32 character codes, return their corresponding glyph IDs.

package/cpp/skia/include/core/SkTypes.h

@@ -11,16 +11,16 @@
 // All of these files should be independent of things users can set via the user config file.
 // They should also be able to be included in any order.
 // IWYU pragma: begin_exports
-#include "include/private/base/SkFeatures.h"
+#include "include/private/SkFeatures.h"
 
 // Load and verify defines from the user config file.
-#include "include/private/base/SkLoadUserConfig.h"
+#include "include/private/SkLoadUserConfig.h"
 
 // Any includes or defines below can be configured by the user config file.
-#include "include/private/base/SkAPI.h"
-#include "include/private/base/SkAssert.h"
-#include "include/private/base/SkAttributes.h"
-#include "include/private/base/SkDebug.h"
+#include "include/private/SkAPI.h"
+#include "include/private/SkAssert.h"
+#include "include/private/SkAttributes.h"
+#include "include/private/SkDebug.h"
 // IWYU pragma: end_exports
 
 #include <cstdint>

package/cpp/skia/include/core/SkUnPreMultiply.h

@@ -10,7 +10,7 @@
 
 #include "include/core/SkColor.h"
 #include "include/core/SkTypes.h"
-#include "include/private/base/SkCPUTypes.h"
+#include "include/private/SkCPUTypes.h"
 
 #include <cstdint>
 

package/cpp/skia/include/core/SkVertices.h

@@ -12,7 +12,7 @@
 #include "include/core/SkPoint.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
-#include "include/private/base/SkAPI.h"
+#include "include/private/SkAPI.h"
 
 #include <cstddef>
 #include <cstdint>

package/cpp/skia/include/core/SkYUVAPixmaps.h

@@ -16,7 +16,7 @@
 #include "include/core/SkSize.h"
 #include "include/core/SkTypes.h"
 #include "include/core/SkYUVAInfo.h"
-#include "include/private/base/SkTo.h"
+#include "include/private/SkTo.h"
 
 #include <array>
 #include <bitset>

package/cpp/skia/include/docs/SkPDFDocument.h

@@ -9,9 +9,9 @@
 #include "include/core/SkScalar.h"
 #include "include/core/SkSpan.h"
 #include "include/core/SkString.h"
-#include "include/private/base/SkAPI.h"
-#include "include/private/base/SkMacros.h"
-#include "include/private/base/SkNoncopyable.h"
+#include "include/private/SkAPI.h"
+#include "include/private/SkMacros.h"
+#include "include/private/SkNoncopyable.h"
 
 #include <cstdint>
 #include <memory>
@@ -158,6 +158,12 @@ struct Metadata {
     */
     int fEncodingQuality = 101;
 
+    /** If true, rasterize gradients with non-opaque stops for print compatibility.
+        Intended only for physical printing; it trades vector fidelity and file
+        size to avoid PDF-to-PostScript converter bugs.
+    */
+    bool fRasterizeAlphaGradientsForPrinting = false;
+
     /** An optional tree of structured document tags that provide
         a semantic representation of the content. The caller
         should retain ownership.

package/cpp/skia/include/effects/SkGradient.h

@@ -14,7 +14,7 @@
 #include "include/core/SkShader.h"
 #include "include/core/SkSpan.h"
 #include "include/core/SkTileMode.h"
-#include "include/private/base/SkAPI.h"
+#include "include/private/SkAPI.h"
 
 class SkMatrix;
 

package/cpp/skia/include/effects/SkPerlinNoiseShader.h

@@ -11,7 +11,7 @@
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkShader.h" // IWYU pragma: keep
-#include "include/private/base/SkAPI.h"
+#include "include/private/SkAPI.h"
 
 struct SkISize;
 

package/cpp/skia/include/effects/SkRuntimeEffect.h

@@ -18,11 +18,11 @@
 #include "include/core/SkSpan.h"
 #include "include/core/SkString.h"
 #include "include/core/SkTypes.h"
+#include "include/private/SkOnce.h"
 #include "include/private/SkSLSampleUsage.h"
-#include "include/private/base/SkOnce.h"
-#include "include/private/base/SkTemplates.h"
-#include "include/private/base/SkTo.h"
-#include "include/private/base/SkTypeTraits.h"
+#include "include/private/SkTemplates.h"
+#include "include/private/SkTo.h"
+#include "include/private/SkTypeTraits.h"
 #include "include/sksl/SkSLDebugTrace.h"
 #include "include/sksl/SkSLVersion.h"
 

package/cpp/skia/include/encode/SkEncoder.h

@@ -9,9 +9,9 @@
 #define SkEncoder_DEFINED
 
 #include "include/core/SkPixmap.h"
-#include "include/private/base/SkAPI.h"
-#include "include/private/base/SkNoncopyable.h"
-#include "include/private/base/SkTemplates.h"
+#include "include/private/SkAPI.h"
+#include "include/private/SkNoncopyable.h"
+#include "include/private/SkTemplates.h"
 
 #include <cstddef>
 #include <cstdint>

package/cpp/skia/include/encode/SkICC.h

@@ -9,7 +9,7 @@
 #define SkICC_DEFINED
 
 #include "include/core/SkRefCnt.h"
-#include "include/private/base/SkAPI.h"
+#include "include/private/SkAPI.h"
 
 #include <cstdint>
 

package/cpp/skia/include/encode/SkJpegEncoder.h

@@ -10,7 +10,7 @@
 
 #include "include/codec/SkEncodedOrigin.h"
 #include "include/core/SkRefCnt.h"
-#include "include/private/base/SkAPI.h"
+#include "include/private/SkAPI.h"
 
 #include <memory>
 #include <optional>

package/cpp/skia/include/encode/SkPngEncoder.h

@@ -10,8 +10,8 @@
 
 #include "include/core/SkDataTable.h"
 #include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
 #include "include/private/SkHdrMetadata.h"
-#include "include/private/base/SkAPI.h"
 
 // TODO(kjlubick) update clients to directly include this
 #include "include/encode/SkEncoder.h"  // IWYU pragma: keep

package/cpp/skia/include/encode/SkPngRustEncoder.h

@@ -12,7 +12,7 @@
 
 #include "include/core/SkDataTable.h"
 #include "include/core/SkRefCnt.h"
-#include "include/private/base/SkAPI.h"
+#include "include/private/SkAPI.h"
 
 class GrDirectContext;
 class SkData;
@@ -21,6 +21,8 @@ class SkImage;
 class SkPixmap;
 class SkWStream;
 
+struct SkGainmapInfo;
+
 namespace SkPngRustEncoder {
 
 /*
@@ -63,6 +65,19 @@ struct Options {
      *  79 characters and it can't contain a non-breaking space character.
      */
     sk_sp<SkDataTable> fComments;
+
+    /**
+     * If non-null, then a gainmap and its metadata will be encoded as png chunks.
+     * The gainmap metadata (info) will be encoded in a gmAP chunk. The
+     * gainmap pixels (encoded as a PNG) will be encoded in a gdAT chunk.
+     * This effectively is Option B proposed in this discussion for adding gainmaps
+     * into PNG: https://github.com/w3c/png/issues/380#issuecomment-2325163149.
+     *
+     * Note that if fGainmapInfo is null, then fGainmap will be ignored (not encoded),
+     * as the gainmap metadata is required to correctly interpret the encoded gainmap.
+     */
+    const SkPixmap* fGainmap = nullptr;
+    const SkGainmapInfo* fGainmapInfo = nullptr;
 };
 
 /**

package/cpp/skia/include/encode/SkWebpEncoder.h

@@ -11,7 +11,7 @@
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSpan.h" // IWYU pragma: keep
 #include "include/encode/SkEncoder.h"
-#include "include/private/base/SkAPI.h"
+#include "include/private/SkAPI.h"
 
 class SkPixmap;
 class SkWStream;

package/cpp/skia/include/gpu/GpuTypes.h

@@ -9,7 +9,7 @@
 #define skgpu_GpuTypes_DEFINED
 
 #include "include/core/SkTypes.h"
-#include "include/private/base/SkMacros.h"
+#include "include/private/SkMacros.h"
 
 /**
  * This file includes numerous public types that are used by all of our gpu backends.

package/cpp/skia/include/gpu/MutableTextureState.h

@@ -10,7 +10,7 @@
 
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkTypes.h"
-#include "include/private/base/SkAnySubclass.h"
+#include "include/private/SkAnySubclass.h"
 
 #include <cstddef>
 

package/cpp/skia/include/gpu/ganesh/GrBackendSemaphore.h

@@ -8,8 +8,8 @@
 #define GrBackendSemaphore_DEFINED
 
 #include "include/gpu/ganesh/GrTypes.h"
-#include "include/private/base/SkAPI.h"
-#include "include/private/base/SkAnySubclass.h"
+#include "include/private/SkAPI.h"
+#include "include/private/SkAnySubclass.h"
 
 #include <cstddef>
 

package/cpp/skia/include/gpu/ganesh/GrBackendSurface.h

@@ -12,9 +12,9 @@
 #include "include/core/SkSize.h"
 #include "include/gpu/GpuTypes.h"
 #include "include/gpu/ganesh/GrTypes.h"
-#include "include/private/base/SkAPI.h"
-#include "include/private/base/SkAnySubclass.h"
-#include "include/private/base/SkDebug.h"
+#include "include/private/SkAPI.h"
+#include "include/private/SkAnySubclass.h"
+#include "include/private/SkDebug.h"
 #include "include/private/gpu/ganesh/GrTypesPriv.h"
 
 class GrBackendFormatData;