@shopify/react-native-skia 1.5.3 → 1.5.4

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

@@ -11,13 +11,17 @@
 #include "include/core/SkPoint.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
+#include "include/core/SkSpan.h"
 #include "include/private/base/SkAPI.h"
+#include "include/private/base/SkAssert.h"
 #include "include/private/base/SkTDArray.h"
 
+#include <cstddef>
 #include <memory>
 
 class SkMatrix;
 class SkPath;
+enum class SkPathVerb;
 
 class SK_API SkContourMeasure : public SkRefCnt {
 public:
@@ -57,6 +61,78 @@ public:
      */
     bool isClosed() const { return fIsClosed; }
 
+    /** Measurement data for individual verbs.
+     */
+    struct VerbMeasure {
+        SkScalar              fDistance; // Cumulative distance along the current contour.
+        SkPathVerb            fVerb;     // Verb type.
+        SkSpan<const SkPoint> fPts;      // Verb points.
+    };
+
+private:
+    struct Segment;
+
+public:
+    /** Utility for iterating over the current contour verbs:
+     *
+     *   for (const auto verb_measure : contour_measure) {
+     *     ...
+     *   }
+     */
+    class ForwardVerbIterator final {
+    public:
+        VerbMeasure operator*() const;
+
+        ForwardVerbIterator& operator++() {
+            SkASSERT(!fSegments.empty());
+
+            fSegments = LastSegForCurrentVerb(fSegments.subspan(1));
+
+            return *this;
+        }
+
+        bool operator==(const ForwardVerbIterator& other) {
+            SkASSERT(fSegments.data() != other.fSegments.data() ||
+                     fSegments.size() == other.fSegments.size());
+            return fSegments.data() == other.fSegments.data();
+        }
+
+        bool operator!=(const ForwardVerbIterator& other) {
+            return !((*this) == other);
+        }
+
+    private:
+        friend class SkContourMeasure;
+
+        ForwardVerbIterator(SkSpan<const Segment> segs, SkSpan<const SkPoint> pts)
+            : fSegments(LastSegForCurrentVerb(segs))
+            , fPts(pts) {}
+
+        static SkSpan<const Segment> LastSegForCurrentVerb(const SkSpan<const Segment>& segs) {
+            size_t i = 1;
+            while (i < segs.size() && segs[0].fPtIndex == segs[i].fPtIndex) {
+                ++i;
+            }
+
+            return segs.subspan(i - 1);
+        }
+
+        // Remaining segments for forward iteration. The first segment in the span is
+        // adjusted to always point to the last segment of the current verb, such that its distance
+        // corresponds to the verb distance.
+        SkSpan<const Segment> fSegments;
+
+        // All path points (indexed in segments).
+        SkSpan<const SkPoint> fPts;
+    };
+
+    ForwardVerbIterator begin() const {
+        return ForwardVerbIterator(fSegments, fPts);
+    }
+    ForwardVerbIterator end() const {
+        return ForwardVerbIterator(SkSpan(fSegments.end(), 0), fPts);
+    }
+
 private:
     struct Segment {
         SkScalar    fDistance;  // total distance up to this point

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

@@ -0,0 +1,48 @@
+/*
+* Copyright 2024 Google Inc.
+*
+* Use of this source code is governed by a BSD-style license that can be
+* found in the LICENSE file.
+*/
+
+#ifndef SKFONTSCANNER_H_
+#define SKFONTSCANNER_H_
+
+#include "include/core/SkFontArguments.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+#include "include/private/base/SkFixed.h"
+#include "include/private/base/SkNoncopyable.h"
+#include "include/private/base/SkTArray.h"
+class SkFontStyle;
+class SkStreamAsset;
+class SkString;
+class SkTypeface;
+
+class SkFontScanner : public SkNoncopyable {
+public:
+    virtual ~SkFontScanner() = default;
+    struct AxisDefinition {
+        SkFourByteTag fTag;
+        SkScalar fMinimum;
+        SkScalar fDefault;
+        SkScalar fMaximum;
+    };
+    typedef skia_private::STArray<4, AxisDefinition, true> AxisDefinitions;
+
+    virtual bool scanFile(SkStreamAsset* stream, int* numFaces) const = 0;
+    virtual bool scanFace(SkStreamAsset* stream, int faceIndex, int* numInstances) const = 0;
+    /* instanceIndex 0 is the default instance, 1 to numInstances are the named instances. */
+    virtual bool scanInstance(SkStreamAsset* stream,
+                              int faceIndex,
+                              int instanceIndex,
+                              SkString* name,
+                              SkFontStyle* style,
+                              bool* isFixedPitch,
+                              AxisDefinitions* axes) const = 0;
+    virtual sk_sp<SkTypeface> MakeFromStream(std::unique_ptr<SkStreamAsset> stream,
+                                             const SkFontArguments& args) const = 0;
+    virtual SkFourByteTag getFactoryId() const = 0;
+};
+
+#endif // SKFONTSCANNER_H_

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

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

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

@@ -26,6 +26,7 @@
 #include <tuple>
 #include <type_traits>
 
+struct SkArc;
 class SkData;
 class SkPathRef;
 class SkRRect;
@@ -280,6 +281,16 @@ public:
     */
     bool isRRect(SkRRect* rrect) const;
 
+    /** Returns true if path is representable as an oval arc. In other words, could this
+        path be drawn using SkCanvas::drawArc.
+
+        arc  receives parameters of arc
+
+       @param arc  storage for arc; may be nullptr
+       @return     true if SkPath contains only a single arc from an oval
+    */
+    bool isArc(SkArc* arc) const;
+
     /** Sets SkPath to its initial state.
         Removes verb array, SkPoint array, and weights, and sets FillType to kWinding.
         Internal storage associated with SkPath is released.

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

@@ -10,14 +10,12 @@
 
 #include "include/core/SkFlattenable.h"
 #include "include/core/SkRefCnt.h"
-#include "include/core/SkScalar.h"
 #include "include/private/base/SkAPI.h"
 
 // TODO(kjlubick) update clients and remove this unnecessary #include
 #include "include/core/SkPath.h"  // IWYU pragma: keep
 
 #include <cstddef>
-#include <cstdint>
 
 class SkMatrix;
 class SkStrokeRec;
@@ -55,27 +53,6 @@ public:
         return kSkPathEffect_Type;
     }
 
-    // move to base?
-
-    enum DashType {
-        kNone_DashType, //!< ignores the info parameter
-        kDash_DashType, //!< fills in all of the info parameter
-    };
-
-    struct DashInfo {
-        DashInfo() : fIntervals(nullptr), fCount(0), fPhase(0) {}
-        DashInfo(SkScalar* intervals, int32_t count, SkScalar phase)
-            : fIntervals(intervals), fCount(count), fPhase(phase) {}
-
-        SkScalar*   fIntervals;         //!< Length of on/off intervals for dashed lines
-                                        //   Even values represent ons, and odds offs
-        int32_t     fCount;             //!< Number of intervals in the dash. Should be even number
-        SkScalar    fPhase;             //!< Offset into the dashed interval pattern
-                                        //   mod the sum of all intervals
-    };
-
-    DashType asADash(DashInfo* info) const;
-
     /**
      *  Given a src path (input) and a stroke-rec (input and output), apply
      *  this effect to the src path, returning the new path in dst, and return

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

@@ -21,6 +21,7 @@
 #include <cstring>
 
 struct SkRect;
+class SkString;
 
 /** \struct SkIRect
     SkIRect holds four 32-bit integer coordinates describing the upper and
@@ -1347,6 +1348,7 @@ public:
         example: https://fiddle.skia.org/c/@Rect_dump
     */
     void dump(bool asHex) const;
+    SkString dumpToString(bool asHex) const;
 
     /** Writes text representation of SkRect to standard output. The representation may be
         directly compiled as C++ code. Floating point values are written

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

@@ -132,6 +132,8 @@ public:
     const char* data() const { return fRec->data(); }
     const char* c_str() const { return fRec->data(); }
     char operator[](size_t n) const { return this->c_str()[n]; }
+    const char* begin() const { return data(); }
+    const char* end() const { return data() + size(); }
 
     bool equals(const SkString&) const;
     bool equals(const char text[]) const;
@@ -177,6 +179,8 @@ public:
 
     char* data();
     char& operator[](size_t n) { return this->data()[n]; }
+    char* begin() { return data(); }
+    char* end() { return data() + size(); }
 
     void reset();
     /** String contents are preserved on resize. (For destructive resize, `set(nullptr, length)`.)

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

@@ -352,6 +352,10 @@ protected:
     // Must return a valid scaler context. It can not return nullptr.
     virtual std::unique_ptr<SkScalerContext> onCreateScalerContext(const SkScalerContextEffects&,
                                                                    const SkDescriptor*) const = 0;
+    virtual std::unique_ptr<SkScalerContext> onCreateScalerContextAsProxyTypeface
+                                                                  (const SkScalerContextEffects&,
+                                                                   const SkDescriptor*,
+                                                                   sk_sp<SkTypeface>) const;
     virtual void onFilterRec(SkScalerContextRec*) const = 0;
     friend class SkScalerContext;  // onFilterRec
 
@@ -420,6 +424,7 @@ private:
     std::unique_ptr<SkAdvancedTypefaceMetrics> getAdvancedMetrics() const;
     friend class SkRandomTypeface;   // getAdvancedMetrics
     friend class SkPDFFont;          // getAdvancedMetrics
+    friend class SkTypeface_fontconfig;
 
     friend class SkFontPriv;         // getGlyphToUnicodeMap
 

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

@@ -96,7 +96,8 @@
 #if defined(SK_HISTOGRAM_ENUMERATION)  || \
     defined(SK_HISTOGRAM_BOOLEAN)      || \
     defined(SK_HISTOGRAM_EXACT_LINEAR) || \
-    defined(SK_HISTOGRAM_MEMORY_KB)
+    defined(SK_HISTOGRAM_MEMORY_KB)    || \
+    defined(SK_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES)
 #  define SK_HISTOGRAMS_ENABLED 1
 #else
 #  define SK_HISTOGRAMS_ENABLED 0
@@ -107,17 +108,21 @@
 #endif
 
 #ifndef SK_HISTOGRAM_ENUMERATION
-#  define SK_HISTOGRAM_ENUMERATION(name, sample, enum_size)
+#  define SK_HISTOGRAM_ENUMERATION(name, sampleEnum, enumSize)
 #endif
 
 #ifndef SK_HISTOGRAM_EXACT_LINEAR
-#  define SK_HISTOGRAM_EXACT_LINEAR(name, sample, value_max)
+#  define SK_HISTOGRAM_EXACT_LINEAR(name, sample, valueMax)
 #endif
 
 #ifndef SK_HISTOGRAM_MEMORY_KB
 #  define SK_HISTOGRAM_MEMORY_KB(name, sample)
 #endif
 
+#ifndef SK_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES
+#  define SK_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES(name, sampleUSec, minUSec, maxUSec, bucketCount)
+#endif
+
 #define SK_HISTOGRAM_PERCENTAGE(name, percent_as_int) \
     SK_HISTOGRAM_EXACT_LINEAR(name, percent_as_int, 101)
 

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

@@ -18,7 +18,7 @@
 class SkCanvas;
 class SkExecutor;
 class SkPDFArray;
-class SkPDFTagTree;
+class SkPDFStructTree;
 class SkWStream;
 
 #define SKPDF_STRING(X) SKPDF_STRING_IMPL(X)
@@ -46,9 +46,10 @@ public:
                            const std::vector<int>& nodeIds);
 
 private:
-    friend class ::SkPDFTagTree;
+    friend class ::SkPDFStructTree;
 
     std::unique_ptr<SkPDFArray> fAttrs;
+    std::vector<int> fElemIds; // element identifiers referenced by fAttrs
 };
 
 /** A node in a PDF structure tree, giving a semantic representation
@@ -60,7 +61,6 @@ struct StructureElementNode {
     SkString fTypeString;
     std::vector<std::unique_ptr<StructureElementNode>> fChildVector;
     int fNodeId = 0;
-    std::vector<int> fAdditionalNodeIds;
     AttributeList fAttributes;
     SkString fAlt;
     SkString fLang;

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

@@ -21,6 +21,7 @@ class SkColorFilter;
  *  ...
  *  5 (or larger) -> colors[5]
  *
+ *  https://fiddle.skia.org/c/@overdrawcolorfilter_grid
  */
 class SK_API SkOverdrawColorFilter {
 public:

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

@@ -162,6 +162,7 @@ public:
 
     // Color filter SkSL requires an entry point that looks like:
     //     vec4 main(vec4 inColor) { ... }
+    //     https://fiddle.skia.org/c/@runtimeeffect_colorfilter_grid
     static Result MakeForColorFilter(SkString sksl, const Options&);
     static Result MakeForColorFilter(SkString sksl) {
         return MakeForColorFilter(std::move(sksl), Options{});
@@ -352,7 +353,7 @@ private:
  * Note that SkRuntimeEffectBuilder is built entirely on the public API of SkRuntimeEffect,
  * so can be used as-is or serve as inspiration for other interfaces or binding techniques.
  */
-class SkRuntimeEffectBuilder {
+class SK_API SkRuntimeEffectBuilder {
 public:
     explicit SkRuntimeEffectBuilder(sk_sp<SkRuntimeEffect> effect)
             : fEffect(std::move(effect))

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

@@ -8,10 +8,12 @@
 #ifndef SkJpegEncoder_DEFINED
 #define SkJpegEncoder_DEFINED
 
+#include "include/codec/SkEncodedOrigin.h"
 #include "include/core/SkRefCnt.h"
 #include "include/private/base/SkAPI.h"
 
 #include <memory>
+#include <optional>
 
 class SkColorSpace;
 class SkData;
@@ -86,6 +88,8 @@ struct Options {
      */
     const skcms_ICCProfile* fICCProfile = nullptr;
     const char* fICCProfileDescription = nullptr;
+
+    std::optional<SkEncodedOrigin> fOrigin;
 };
 
 /**

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

@@ -11,9 +11,9 @@
 #include "include/core/SkData.h"
 #include "include/core/SkString.h"
 #include "include/core/SkTypes.h"
+#include "include/gpu/ShaderErrorHandler.h"
 #include "include/gpu/ganesh/GrDriverBugWorkarounds.h"
 #include "include/gpu/ganesh/GrTypes.h"
-#include "include/gpu/ShaderErrorHandler.h"
 #include "include/private/gpu/ganesh/GrTypesPriv.h"
 
 #include <optional>
@@ -176,6 +176,13 @@ struct SK_API GrContextOptions {
      */
     bool fAvoidStencilBuffers = false;
 
+    /**
+     * If true, texture fetches from mip-mapped textures will be biased to read larger MIP levels.
+     * This has the effect of sharpening those textures, at the cost of some aliasing, and possible
+     * performance impact.
+     */
+    bool fSharpenMipmappedTextures = true;
+
     /**
      * Enables driver workaround to use draws instead of HW clears, e.g. glClear on the GL backend.
      */

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

@@ -479,10 +479,25 @@ public:
      * If it returns false, then those same semaphores will not have been submitted and we will not
      * try to submit them again. The caller is free to delete the semaphores at any time.
      *
-     * If sync flag is GrSyncCpu::kYes, this function will return once the gpu has finished with all
-     * submitted work.
+     * If GrSubmitInfo::fSync flag is GrSyncCpu::kYes, this function will return once the gpu has
+     * finished with all submitted work.
+     *
+     * If GrSubmitInfo::fMarkBoundary flag is GrMarkFrameBoundary::kYes and the GPU supports a way
+     * to be notified about frame boundaries, then we will notify the GPU during/after the
+     * submission of work to the GPU. GrSubmitInfo::fFrameID is a frame ID that is passed to the
+     * GPU when marking a boundary. Ideally this value should be unique for each frame. Currently
+     * marking frame boundaries is only supported with the Vulkan backend and only if the
+     * VK_EXT_frame_boudnary extenstion is available.
      */
-    bool submit(GrSyncCpu sync = GrSyncCpu::kNo);
+    bool submit(const GrSubmitInfo&);
+
+    bool submit(GrSyncCpu sync = GrSyncCpu::kNo) {
+        GrSubmitInfo info;
+        info.fSync = sync;
+
+        return this->submit(info);
+    }
+
 
     /**
      * Checks whether any asynchronous work is complete and if so calls related callbacks.

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

@@ -174,4 +174,15 @@ enum class GrSyncCpu : bool {
     kYes = true,
 };
 
+enum class GrMarkFrameBoundary : bool {
+    kNo = false,
+    kYes = true,
+};
+
+struct GrSubmitInfo {
+    GrSyncCpu fSync = GrSyncCpu::kNo;
+    GrMarkFrameBoundary fMarkBoundary = GrMarkFrameBoundary::kNo;
+    uint64_t fFrameID = 0;
+};
+
 #endif

package/cpp/skia/include/gpu/ganesh/gl/GrGLFunctions.h

@@ -104,7 +104,6 @@ using GrGLGetProgramInfoLogFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint program, G
 using GrGLGetProgramivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint program, GrGLenum pname, GrGLint* params);
 using GrGLGetQueryivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum GLtarget, GrGLenum pname, GrGLint* params);
 using GrGLGetQueryObjecti64vFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint id, GrGLenum pname, GrGLint64* params);
-using GrGLGetQueryObjectivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint id, GrGLenum pname, GrGLint* params);
 using GrGLGetQueryObjectui64vFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint id, GrGLenum pname, GrGLuint64* params);
 using GrGLGetQueryObjectuivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLuint id, GrGLenum pname, GrGLuint* params);
 using GrGLGetRenderbufferParameterivFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLenum target, GrGLenum pname, GrGLint* params);
@@ -219,8 +218,13 @@ using GrGLMultiDrawElementsInstancedBaseVertexBaseInstanceFn = GrGLvoid GR_GL_FU
 /* ARB_sync */
 using GrGLFenceSyncFn = GrGLsync GR_GL_FUNCTION_TYPE(GrGLenum condition, GrGLbitfield flags);
 using GrGLIsSyncFn = GrGLboolean GR_GL_FUNCTION_TYPE(GrGLsync sync);
+#if defined(__EMSCRIPTEN__)
+using GrGLClientWaitSyncFn = GrGLenum GR_GL_FUNCTION_TYPE(GrGLsync sync, GrGLbitfield flags, GrGLint timeoutLo, GrGLint timeoutHi);
+using GrGLWaitSyncFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsync sync, GrGLbitfield flags, GrGLuint timeoutLo, GrGLuint timeoutHi);
+#else
 using GrGLClientWaitSyncFn = GrGLenum GR_GL_FUNCTION_TYPE(GrGLsync sync, GrGLbitfield flags, GrGLuint64 timeout);
 using GrGLWaitSyncFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsync sync, GrGLbitfield flags, GrGLuint64 timeout);
+#endif
 using GrGLDeleteSyncFn = GrGLvoid GR_GL_FUNCTION_TYPE(GrGLsync sync);
 
 /* ARB_internalformat_query */

package/cpp/skia/include/gpu/ganesh/gl/GrGLInterface.h

@@ -174,7 +174,6 @@ public:
         GrGLFunction<GrGLGetProgramInfoLogFn> fGetProgramInfoLog;
         GrGLFunction<GrGLGetProgramivFn> fGetProgramiv;
         GrGLFunction<GrGLGetQueryObjecti64vFn> fGetQueryObjecti64v;
-        GrGLFunction<GrGLGetQueryObjectivFn> fGetQueryObjectiv;
         GrGLFunction<GrGLGetQueryObjectui64vFn> fGetQueryObjectui64v;
         GrGLFunction<GrGLGetQueryObjectuivFn> fGetQueryObjectuiv;
         GrGLFunction<GrGLGetQueryivFn> fGetQueryiv;

package/cpp/skia/include/gpu/graphite/GraphiteTypes.h

@@ -9,6 +9,7 @@
 #define skgpu_graphite_GraphiteTypes_DEFINED
 
 #include "include/core/SkPoint.h"
+#include "include/core/SkRect.h"
 #include "include/core/SkTypes.h"
 #include "include/gpu/GpuTypes.h"
 
@@ -44,6 +45,9 @@ using GpuFinishedProc = void (*)(GpuFinishedContext finishedContext, CallbackRes
  *
  * fTargetTranslation is an additional translation applied to draws targeting fTargetSurface.
  *
+ * fTargetClip is an additional clip applied to draws targeting fTargetSurface. It is defined in the
+ * local replay space, that is, with fTargetTranslation applied. An empty clip will not be applied.
+ *
  * The client may pass in two arrays of initialized BackendSemaphores to be included in the
  * command stream. At some time before issuing commands in the Recording, the fWaitSemaphores will
  * be waited on by the gpu. We only guarantee these wait semaphores block transfer and fragment
@@ -62,6 +66,7 @@ struct InsertRecordingInfo {
 
     SkSurface* fTargetSurface = nullptr;
     SkIVector fTargetTranslation = {0, 0};
+    SkIRect fTargetClip = {0, 0, 0, 0};
     MutableTextureState* fTargetTextureState = nullptr;
 
     size_t fNumWaitSemaphores = 0;
@@ -150,7 +155,10 @@ enum DrawTypeFlags : uint16_t {
     //    TessellateCurvesRenderStep[*] for [even-odd], [winding]
     //    MiddleOutFanRenderStep[*] for [even-odd], [winding]
     kNonSimpleShape   = 0b10000000,
+
+    kLast = kNonSimpleShape,
 };
+static constexpr int kDrawTypeFlagsCnt = static_cast<int>(DrawTypeFlags::kLast) + 1;
 
 } // namespace skgpu::graphite
 

package/cpp/skia/include/gpu/graphite/Recorder.h

@@ -58,7 +58,6 @@ class UploadBufferManager;
 class UploadList;
 
 template<typename T> class PipelineDataCache;
-using UniformDataCache = PipelineDataCache<UniformDataBlock>;
 using TextureDataCache = PipelineDataCache<TextureDataBlock>;
 
 struct SK_API RecorderOptions final {
@@ -262,7 +261,6 @@ private:
     // Aggregated one-time uploads that preceed all tasks in the root task list.
     std::unique_ptr<UploadList> fRootUploads;
 
-    std::unique_ptr<UniformDataCache> fUniformDataCache;
     std::unique_ptr<TextureDataCache> fTextureDataCache;
     std::unique_ptr<DrawBufferManager> fDrawBufferManager;
     std::unique_ptr<UploadBufferManager> fUploadBufferManager;

package/cpp/skia/include/gpu/graphite/precompile/PaintOptions.h

@@ -32,6 +32,7 @@ class KeyContext;
 class PaintOptionsPriv;
 class PaintParamsKeyBuilder;
 class PipelineDataGatherer;
+struct RenderPassDesc;
 class UniquePaintParamsID;
 
 /** \class PaintOptions
@@ -171,14 +172,16 @@ private:
     typedef std::function<void(UniquePaintParamsID id,
                                DrawTypeFlags,
                                bool withPrimitiveBlender,
-                               Coverage)> ProcessCombination;
+                               Coverage,
+                               const RenderPassDesc&)> ProcessCombination;
 
     void buildCombinations(const KeyContext&,
                            PipelineDataGatherer*,
-                           DrawTypeFlags drawTypes,
+                           DrawTypeFlags,
                            bool addPrimitiveBlender,
-                           Coverage coverage,
-                           const ProcessCombination& processCombination) const;
+                           Coverage,
+                           const RenderPassDesc&,
+                           const ProcessCombination&) const;
 
     skia_private::TArray<sk_sp<PrecompileShader>> fShaderOptions;
     skia_private::TArray<sk_sp<PrecompileColorFilter>> fColorFilterOptions;

package/cpp/skia/include/gpu/graphite/precompile/PrecompileImageFilter.h

@@ -61,10 +61,12 @@ private:
 
     virtual void onCreatePipelines(const KeyContext&,
                                    PipelineDataGatherer*,
+                                   const RenderPassDesc&,
                                    const PaintOptions::ProcessCombination&) const = 0;
 
     void createPipelines(const KeyContext&,
                          PipelineDataGatherer*,
+                         const RenderPassDesc&,
                          const PaintOptions::ProcessCombination&);
 
     skia_private::AutoSTArray<2, sk_sp<PrecompileImageFilter>> fInputs;

package/cpp/skia/include/gpu/graphite/precompile/PrecompileMaskFilter.h

@@ -31,6 +31,8 @@ protected:
 
     virtual void createPipelines(const KeyContext&,
                                  PipelineDataGatherer*,
+                                 const PaintOptions&,
+                                 const RenderPassDesc&,
                                  const PaintOptions::ProcessCombination&) const = 0;
 };
 

package/cpp/skia/include/ports/SkFontMgr_android_ndk.h

@@ -0,0 +1,25 @@
+/*
+ * 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 SkFontMgr_android_ndk_DEFINED
+#define SkFontMgr_android_ndk_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
+#include <memory>
+
+class SkFontMgr;
+class SkFontScanner;
+
+/** Create a font manager for Android NDK. May return nullptr if unavailable (API < 29). */
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_AndroidNDK(bool cacheFontFiles);
+
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_AndroidNDK(bool cacheFontFiles,
+                                                 std::unique_ptr<SkFontScanner> scanner);
+
+#endif // SkFontMgr_android_ndk_DEFINED

package/cpp/skia/include/ports/SkFontMgr_fontconfig.h

@@ -8,8 +8,9 @@
 #ifndef SkFontMgr_fontconfig_DEFINED
 #define SkFontMgr_fontconfig_DEFINED
 
-#include "include/core/SkRefCnt.h"
 #include <fontconfig/fontconfig.h>
+#include "include/core/SkRefCnt.h"
+#include <memory>
 
 class SkFontMgr;
 
@@ -17,6 +18,7 @@ class SkFontMgr;
  *  If 'fc' is NULL, will use a new default config.
  *  Takes ownership of 'fc' and will call FcConfigDestroy on it.
  */
+class SkFontScanner;
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_FontConfig(FcConfig* fc, std::unique_ptr<SkFontScanner> scanner);
 SK_API sk_sp<SkFontMgr> SkFontMgr_New_FontConfig(FcConfig* fc);
-
 #endif // #ifndef SkFontMgr_fontconfig_DEFINED

package/cpp/skia/include/ports/SkFontScanner_Fontations.h

@@ -0,0 +1,15 @@
+/*
+* Copyright 2024 Google Inc.
+*
+* Use of this source code is governed by a BSD-style license that can be
+* found in the LICENSE file.
+*/
+
+#ifndef SKFONTSCANNER_FONTATIONS_H_
+#define SKFONTSCANNER_FONTATIONS_H_
+
+#include "include/core/SkFontScanner.h"
+
+SK_API std::unique_ptr<SkFontScanner> SkFontScanner_Make_Fontations();
+
+#endif // SKFONTSCANNER_FONTATIONS_H_