@shopify/react-native-skia 0.1.234 → 0.1.236

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

@@ -69,6 +69,19 @@ public:
      */
     static int SetFontCacheCountLimit(int count);
 
+    /**
+     *  Return the current limit to the number of entries in the typeface cache.
+     *  A cache "entry" is associated with each typeface.
+     */
+    static int GetTypefaceCacheCountLimit();
+
+    /**
+     *  Set the limit to the number of entries in the typeface cache, and return
+     *  the previous value. Changes to this only take effect the next time
+     *  each cache object is modified.
+     */
+    static int SetTypefaceCacheCountLimit(int count);
+
     /**
      *  For debugging purposes, this will attempt to purge the font cache. It
      *  does not change the limit, but will cause subsequent font measures and

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

@@ -15,6 +15,7 @@
 #include "include/core/SkString.h"
 #include "include/effects/SkRuntimeEffect.h"
 #include "include/private/base/SkAPI.h"
+#include "include/private/base/SkTArray.h"
 
 #include <cstddef>
 #include <cstdint>
@@ -168,10 +169,7 @@ public:
      */
     SkSpan<const Uniform> uniforms() const { return SkSpan(fUniforms); }
 
-    /**
-     * Provides basic info about individual children: names, indices and runtime effect type.
-     * TODO(b/40045302): SkMesh will currently reject mesh specifications that include child effects
-     */
+    /** Provides basic info about individual children: names, indices and runtime effect type. */
     SkSpan<const Child> children() const { return SkSpan(fChildren); }
 
     /** Returns a pointer to the named child's description, or nullptr if not found. */
@@ -188,6 +186,8 @@ public:
 
     size_t stride() const { return fStride; }
 
+    SkColorSpace* colorSpace() const { return fColorSpace.get(); }
+
 private:
     friend struct SkMeshSpecificationPriv;
 
@@ -317,8 +317,6 @@ public:
      * If the mesh is invalid the returned string give contain the reason for the failure (e.g. the
      * vertex buffer was null or uniform data too small).
      */
-
-    // TODO(b/40045302): support for `children` is a work-in-progress
     static Result Make(sk_sp<SkMeshSpecification>,
                        Mode,
                        sk_sp<VertexBuffer>,
@@ -334,8 +332,6 @@ public:
      * If the mesh is invalid the returned string give contain the reason for the failure (e.g. the
      * index buffer was null or uniform data too small).
      */
-
-    // TODO(b/40045302): support for `children` is a work-in-progress
     static Result MakeIndexed(sk_sp<SkMeshSpecification>,
                               Mode,
                               sk_sp<VertexBuffer>,
@@ -383,7 +379,7 @@ private:
     sk_sp<IndexBuffer>  fIB;
 
     sk_sp<const SkData> fUniforms;
-    std::vector<ChildPtr> fChildren;
+    skia_private::STArray<2, ChildPtr> fChildren;
 
     size_t fVOffset = 0;  // Must be a multiple of spec->stride()
     size_t fVCount  = 0;
@@ -405,14 +401,14 @@ namespace SkMeshes {
  * @param  data              The data used to populate the buffer, or nullptr to create a zero-
  *                           initialized buffer.
  * @param  size              Both the size of the data in 'data' and the size of the resulting
- *                           buffer.
+ *                           buffer, in bytes.
  */
 SK_API sk_sp<SkMesh::IndexBuffer> MakeIndexBuffer(const void* data, size_t size);
 
 /**
  * Makes a copy of an index buffer. The copy will be CPU-backed.
  */
-SK_API sk_sp<SkMesh::IndexBuffer> CopyIndexBuffer(sk_sp<SkMesh::IndexBuffer>);
+SK_API sk_sp<SkMesh::IndexBuffer> CopyIndexBuffer(const sk_sp<SkMesh::IndexBuffer>&);
 
 /**
  * Makes a CPU-backed vertex buffer to be used with SkMeshes.
@@ -420,14 +416,14 @@ SK_API sk_sp<SkMesh::IndexBuffer> CopyIndexBuffer(sk_sp<SkMesh::IndexBuffer>);
  * @param  data              The data used to populate the buffer, or nullptr to create a zero-
  *                           initialized buffer.
  * @param  size              Both the size of the data in 'data' and the size of the resulting
- *                           buffer.
+ *                           buffer, in bytes.
  */
 SK_API sk_sp<SkMesh::VertexBuffer> MakeVertexBuffer(const void*, size_t size);
 
 /**
  * Makes a copy of a vertex buffer.  The copy will be CPU-backed.
  */
-SK_API sk_sp<SkMesh::VertexBuffer> CopyVertexBuffer(sk_sp<SkMesh::VertexBuffer>);
+SK_API sk_sp<SkMesh::VertexBuffer> CopyVertexBuffer(const sk_sp<SkMesh::VertexBuffer>&);
 }  // namespace SkMeshes
 
 #endif

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

@@ -5,5 +5,5 @@
  * found in the LICENSE file.
  */
 #ifndef SK_MILESTONE
-#define SK_MILESTONE 119
+#define SK_MILESTONE 122
 #endif

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

@@ -79,6 +79,8 @@ public:
     void    dump();
 #endif
 
+    const SkContourMeasure* currentMeasure() const { return fContour.get(); }
+
 private:
     SkContourMeasureIter    fIter;
     sk_sp<SkContourMeasure> fContour;

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

@@ -12,12 +12,14 @@
 #include "include/private/base/SkAPI.h"
 
 #include <cstddef>
+#include <optional>
 
 class SkData;
 class SkImage;
 class SkPicture;
 class SkTypeface;
 class SkReadBuffer;
+enum SkAlphaType : int;
 namespace sktext::gpu {
     class Slug;
 }
@@ -48,10 +50,25 @@ using SkDeserialPictureProc = sk_sp<SkPicture> (*)(const void* data, size_t leng
  *
  *  This will also be used to decode the internal mipmap layers that are saved on some images.
  *
- *  Note that unlike SkDeserialPictureProc and SkDeserialTypefaceProc, return nullptr from this
- *  does not indicate failure, but is a signal for Skia to take its default action.
+ *  An explicit SkAlphaType may have been encoded in the bytestream; if not, then the passed in
+ *  optional will be not present.
+ *
+ *  Clients should set at least SkDeserialImageProc; SkDeserialImageFromDataProc may be called
+ *  if the internal implementation has a SkData copy already. Implementations of SkDeserialImageProc
+ *  must make a copy of any data they needed after the proc finishes, since the data will go away
+ *  after serialization ends.
  */
+#if !defined(SK_LEGACY_DESERIAL_IMAGE_PROC)
 using SkDeserialImageProc = sk_sp<SkImage> (*)(const void* data, size_t length, void* ctx);
+#else
+using SkDeserialImageProc = sk_sp<SkImage> (*)(const void* data,
+                                               size_t length,
+                                               std::optional<SkAlphaType>,
+                                               void* ctx);
+#endif
+using SkDeserialImageFromDataProc = sk_sp<SkImage> (*)(sk_sp<SkData>,
+                                                       std::optional<SkAlphaType>,
+                                                       void* ctx);
 
 /**
  * Slugs are currently only deserializable with a GPU backend. Clients will not be able to
@@ -78,22 +95,23 @@ struct SK_API SkSerialProcs {
 };
 
 struct SK_API SkDeserialProcs {
-    SkDeserialPictureProc   fPictureProc = nullptr;
-    void*                   fPictureCtx = nullptr;
+    SkDeserialPictureProc        fPictureProc = nullptr;
+    void*                        fPictureCtx = nullptr;
 
-    SkDeserialImageProc     fImageProc = nullptr;
-    void*                   fImageCtx = nullptr;
+    SkDeserialImageProc          fImageProc = nullptr;
+    SkDeserialImageFromDataProc  fImageDataProc = nullptr;
+    void*                        fImageCtx = nullptr;
 
-    SkSlugProc              fSlugProc = nullptr;
-    void*                   fSlugCtx = nullptr;
+    SkSlugProc                   fSlugProc = nullptr;
+    void*                        fSlugCtx = nullptr;
 
-    SkDeserialTypefaceProc  fTypefaceProc = nullptr;
-    void*                   fTypefaceCtx = nullptr;
+    SkDeserialTypefaceProc       fTypefaceProc = nullptr;
+    void*                        fTypefaceCtx = nullptr;
 
     // This looks like a flag, but it could be considered a proc as well (one that takes no
     // parameters and returns a bool). Given that there are only two valid implementations of that
     // proc, we just insert the bool directly.
-    bool                    fAllowSkSL = true;
+    bool                         fAllowSkSL = true;
 };
 
 #endif

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

@@ -52,13 +52,13 @@ struct SkSize {
     SkScalar fWidth;
     SkScalar fHeight;
 
-    static SkSize Make(SkScalar w, SkScalar h) { return {w, h}; }
+    static constexpr SkSize Make(SkScalar w, SkScalar h) { return {w, h}; }
 
-    static SkSize Make(const SkISize& src) {
+    static constexpr SkSize Make(const SkISize& src) {
         return {SkIntToScalar(src.width()), SkIntToScalar(src.height())};
     }
 
-    static SkSize MakeEmpty() { return {0, 0}; }
+    static constexpr SkSize MakeEmpty() { return {0, 0}; }
 
     void set(SkScalar w, SkScalar h) { *this = SkSize{w, h}; }
 

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

@@ -25,19 +25,6 @@ class SkStreamAsset;
 /**
  *  SkStream -- abstraction for a source of bytes. Subclasses can be backed by
  *  memory, or a file, or something else.
- *
- *  NOTE:
- *
- *  Classic "streams" APIs are sort of async, in that on a request for N
- *  bytes, they may return fewer than N bytes on a given call, in which case
- *  the caller can "try again" to get more bytes, eventually (modulo an error)
- *  receiving their total N bytes.
- *
- *  Skia streams behave differently. They are effectively synchronous, and will
- *  always return all N bytes of the request if possible. If they return fewer
- *  (the read() call returns the number of bytes read) then that means there is
- *  no more data (at EOF or hit an error). The caller should *not* call again
- *  in hopes of fulfilling more of the request.
  */
 class SK_API SkStream {
 public:
@@ -81,6 +68,9 @@ public:
     virtual size_t peek(void* /*buffer*/, size_t /*size*/) const { return 0; }
 
     /** Returns true when all the bytes in the stream have been read.
+     *  As SkStream represents synchronous I/O, isAtEnd returns false when the
+     *  final stream length isn't known yet, even when all the bytes available
+     *  so far have been read.
      *  This may return true early (when there are no more bytes to be read)
      *  or late (after the first unsuccessful read).
      */

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

@@ -604,9 +604,12 @@ public:
     const SkSurfaceProps& props() const { return fProps; }
 
     /** Inserts a list of GPU semaphores that the current GPU-backed API must wait on before
-        executing any more commands on the GPU for this surface. If this call returns false, then
-        the GPU back-end will not wait on any passed in semaphores, and the client will still own
-        the semaphores, regardless of the value of deleteSemaphoresAfterWait.
+        executing any more commands on the GPU for this surface. We only guarantee blocking
+        transfer and fragment shader work, but may block earlier stages as well depending on the
+        backend.
+        If this call returns false, then the GPU back-end will not wait on any passed in
+        semaphores, and the client will still own the semaphores, regardless of the value of
+        deleteSemaphoresAfterWait.
 
         If deleteSemaphoresAfterWait is false then Skia will not delete the semaphores. In this case
         it is the client's responsibility to not destroy or attempt to reuse the semaphores until it

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

@@ -59,15 +59,13 @@ public:
         // Currently this only impacts GPU backends
         kAlwaysDither_Flag              = 1 << 2,
     };
-    /** Deprecated alias used by Chromium. Will be removed. */
-    static const Flags kUseDistanceFieldFonts_Flag = kUseDeviceIndependentFonts_Flag;
 
     /** No flags, unknown pixel geometry. */
     SkSurfaceProps();
     SkSurfaceProps(uint32_t flags, SkPixelGeometry);
 
-    SkSurfaceProps(const SkSurfaceProps&);
-    SkSurfaceProps& operator=(const SkSurfaceProps&);
+    SkSurfaceProps(const SkSurfaceProps&) = default;
+    SkSurfaceProps& operator=(const SkSurfaceProps&) = default;
 
     SkSurfaceProps cloneWithPixelGeometry(SkPixelGeometry newPixelGeometry) const {
         return SkSurfaceProps(fFlags, newPixelGeometry);

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

@@ -89,6 +89,21 @@ public:
      */
     virtual void dumpWrappedState(const char* /*dumpName*/, bool /*isWrappedObject*/) {}
 
+    /**
+     * Returns true if we should dump unbudgeted objects. Unbudgeted objects can either come from
+     * wrapped objects passed into Skia from the client or from Skia created objects currently held
+     * by the client in a public Skia object (e.g. SkSurface or SkImage). This call is only used
+     * when dumping Graphite memory statistics.
+     */
+    virtual bool shouldDumpUnbudgetedObjects() const { return true; }
+
+    /**
+     * If shouldDumpUnbudgetedObjects() returns true then this function will be called to populate
+     * the output with information on whether the item being dumped is budgeted. This call is only
+     * used when dumping Graphite memory statistics.
+     */
+    virtual void dumpBudgetedState(const char* /*dumpName*/, bool /*isBudgeted*/) {}
+
 protected:
     virtual ~SkTraceMemoryDump() = default;
     SkTraceMemoryDump() = default;

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

@@ -24,6 +24,7 @@
 
 class SkData;
 class SkDescriptor;
+class SkFontMgr;
 class SkFontDescriptor;
 class SkScalerContext;
 class SkStream;
@@ -36,10 +37,6 @@ struct SkScalerContextRec;
 
 using SkTypefaceID = uint32_t;
 
-// SkFontID is deprecated, please use SkTypefaceID.
-using SkFontID = SkTypefaceID;
-
-
 /** Machine endian. */
 typedef uint32_t SkFontTableTag;
 
@@ -103,46 +100,13 @@ public:
      */
     SkTypefaceID uniqueID() const { return fUniqueID; }
 
-    /** Return the uniqueID for the specified typeface. If the face is null,
-        resolve it to the default font and return its uniqueID. Will never
-        return 0.
-    */
-    static SkTypefaceID UniqueID(const SkTypeface* face);
-
     /** Returns true if the two typefaces reference the same underlying font,
-        handling either being null (treating null as the default font)
+        handling either being null (treating null as not equal to any font).
      */
     static bool Equal(const SkTypeface* facea, const SkTypeface* faceb);
 
-    /** Returns the default normal typeface, which is never nullptr. */
-    static sk_sp<SkTypeface> MakeDefault();
-
-    /** Creates a new reference to the typeface that most closely matches the
-        requested familyName and fontStyle. This method allows extended font
-        face specifiers as in the SkFontStyle type. Will never return null.
-
-        @param familyName  May be NULL. The name of the font family.
-        @param fontStyle   The style of the typeface.
-        @return reference to the closest-matching typeface. Call must call
-              unref() when they are done.
-    */
-    static sk_sp<SkTypeface> MakeFromName(const char familyName[], SkFontStyle fontStyle);
-
-    /** Return a new typeface given a file. If the file does not exist, or is
-        not a valid font file, returns nullptr.
-    */
-    static sk_sp<SkTypeface> MakeFromFile(const char path[], int index = 0);
-
-    /** Return a new typeface given a stream. If the stream is
-        not a valid font file, returns nullptr. Ownership of the stream is
-        transferred, so the caller must not reference it again.
-    */
-    static sk_sp<SkTypeface> MakeFromStream(std::unique_ptr<SkStreamAsset> stream, int index = 0);
-
-    /** Return a new typeface given a SkData. If the data is null, or is not a valid font file,
-     *  returns nullptr.
-     */
-    static sk_sp<SkTypeface> MakeFromData(sk_sp<SkData>, int index = 0);
+    /** Returns a non-null typeface which contains no glyphs. */
+    static sk_sp<SkTypeface> MakeEmpty();
 
     /** Return a new typeface based on this typeface but parameterized as specified in the
         SkFontArguments. If the SkFontArguments does not supply an argument for a parameter
@@ -177,9 +141,11 @@ public:
     /** Given the data previously written by serialize(), return a new instance
         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).
         Does not affect ownership of SkStream.
      */
-    static sk_sp<SkTypeface> MakeDeserialize(SkStream*);
+
+    static sk_sp<SkTypeface> MakeDeserialize(SkStream*, sk_sp<SkFontMgr> lastResortMgr);
 
     /**
      *  Given an array of UTF32 character codes, return their corresponding glyph IDs.
@@ -454,21 +420,7 @@ private:
     friend class SkRandomTypeface;   // getAdvancedMetrics
     friend class SkPDFFont;          // getAdvancedMetrics
 
-    /** Style specifies the intrinsic style attributes of a given typeface */
-    enum Style {
-        kNormal = 0,
-        kBold   = 0x01,
-        kItalic = 0x02,
-
-        // helpers
-        kBoldItalic = 0x03
-    };
-    static SkFontStyle FromOldStyle(Style oldStyle);
-    static SkTypeface* GetDefaultTypeface(Style style = SkTypeface::kNormal);
-
-    friend class SkFontPriv;         // GetDefaultTypeface
-    friend class SkPaintPriv;        // GetDefaultTypeface
-    friend class SkFont;             // getGlyphToUnicodeMap
+    friend class SkFontPriv;         // getGlyphToUnicodeMap
 
 private:
     SkTypefaceID        fUniqueID;

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

@@ -86,6 +86,14 @@
     #define SK_GAMMA_EXPONENT (0.0f)  // SRGB
 #endif
 
+#if !defined(SK_GAMMA_CONTRAST)
+    // A value of 0.5 for SK_GAMMA_CONTRAST appears to be a good compromise.
+    // With lower values small text appears washed out (though correctly so).
+    // With higher values lcd fringing is worse and the smoothing effect of
+    // partial coverage is diminished.
+    #define SK_GAMMA_CONTRAST (0.5f)
+#endif
+
 #if defined(SK_HISTOGRAM_ENUMERATION)  || \
     defined(SK_HISTOGRAM_BOOLEAN)      || \
     defined(SK_HISTOGRAM_EXACT_LINEAR) || \

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

@@ -61,7 +61,7 @@ public:
         kHasTexCoords_BuilderFlag   = 1 << 0,
         kHasColors_BuilderFlag      = 1 << 1,
     };
-    class Builder {
+    class SK_API Builder {
     public:
         Builder(VertexMode mode, int vertexCount, int indexCount, uint32_t flags);
 

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

@@ -0,0 +1,53 @@
+/*
+ * 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 SkMultiPictureDocument_DEFINED
+#define SkMultiPictureDocument_DEFINED
+
+#include "include/core/SkPicture.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSize.h"
+#include "include/core/SkTypes.h"
+
+#include <functional>
+
+class SkDocument;
+class SkStreamSeekable;
+class SkWStream;
+struct SkDeserialProcs;
+struct SkSerialProcs;
+
+struct SkDocumentPage {
+    sk_sp<SkPicture> fPicture;
+    SkSize fSize;
+};
+
+namespace SkMultiPictureDocument {
+/**
+ *  Writes into a file format that is similar to SkPicture::serialize()
+ *  Accepts a callback for endPage behavior
+ */
+SK_API sk_sp<SkDocument> Make(SkWStream* dst, const SkSerialProcs* = nullptr,
+                              std::function<void(const SkPicture*)> onEndPage = nullptr);
+
+/**
+ *  Returns the number of pages in the SkMultiPictureDocument.
+ */
+SK_API int ReadPageCount(SkStreamSeekable* src);
+
+/**
+ *  Read the SkMultiPictureDocument into the provided array of pages.
+ *  dstArrayCount must equal SkMultiPictureDocumentReadPageCount().
+ *  Return false on error.
+ */
+SK_API bool Read(SkStreamSeekable* src,
+                 SkDocumentPage* dstArray,
+                 int dstArrayCount,
+                 const SkDeserialProcs* = nullptr);
+}  // namespace SkMultiPictureDocument
+
+#endif  // SkMultiPictureDocument_DEFINED

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

@@ -117,6 +117,12 @@ struct Metadata {
     */
     DateTime fModified = {0, 0, 0, 0, 0, 0, 0, 0};
 
+    /** The natural language of the text in the PDF. If fLang is empty, the root
+        StructureElementNode::fLang will be used (if not empty). Text not in
+        this language should be marked with StructureElementNode::fLang.
+    */
+    SkString fLang;
+
     /** The DPI (pixels-per-inch) at which features without native PDF support
         will be rasterized (e.g. draw image with perspective, draw text with
         perspective, ...)  A larger DPI would create a PDF that reflects the
@@ -145,6 +151,11 @@ struct Metadata {
     */
     StructureElementNode* fStructureElementTreeRoot = nullptr;
 
+    enum class Outline : int {
+        None = 0,
+        StructureElementHeaders = 1,
+    } fOutline = Outline::None;
+
     /** Executor to handle threaded work within PDF Backend. If this is nullptr,
         then all work will be done serially on the main thread. To have worker
         threads assist with various tasks, set this to a valid SkExecutor

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

@@ -79,8 +79,17 @@ public:
             kSRGBLinear,
             kLab,
             kOKLab,
+            // This is the same as kOKLab, except it has a simplified version of the CSS gamut
+            // mapping algorithm (https://www.w3.org/TR/css-color-4/#css-gamut-mapping)
+            // into Rec2020 space applied to it.
+            // Warning: This space is experimental and should not be used in production.
+            kOKLabGamutMap,
             kLCH,
             kOKLCH,
+            // This is the same as kOKLCH, except it has the same gamut mapping applied to it
+            // as kOKLabGamutMap does.
+            // Warning: This space is experimental and should not be used in production.
+            kOKLCHGamutMap,
             kSRGB,
             kHSL,
             kHWB,

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

@@ -59,7 +59,7 @@ class Program;
 class SK_API SkRuntimeEffect : public SkRefCnt {
 public:
     // Reflected description of a uniform variable in the effect's SkSL
-    struct Uniform {
+    struct SK_API Uniform {
         enum class Type {
             kFloat,
             kFloat2,
@@ -180,7 +180,7 @@ public:
     }
 
     // Object that allows passing a SkShader, SkColorFilter or SkBlender as a child
-    class ChildPtr {
+    class SK_API ChildPtr {
     public:
         ChildPtr() = default;
         ChildPtr(sk_sp<SkShader> s) : fChild(std::move(s)) {}
@@ -305,11 +305,7 @@ private:
 
     const SkSL::RP::Program* getRPProgram(SkSL::DebugTracePriv* debugTrace) const;
 
-#if defined(SK_GANESH)
-    friend class GrSkSLFP;             // fBaseProgram, fSampleUsages
-    friend class GrGLSLSkSLFP;         //
-#endif
-
+    friend class GrSkSLFP;              // usesColorTransform
     friend class SkRuntimeShader;       // fBaseProgram, fMain, fSampleUsages, getRPProgram()
     friend class SkRuntimeBlender;      //
     friend class SkRuntimeColorFilter;  //