@shopify/react-native-skia 2.3.0 → 2.3.4

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

@@ -10,6 +10,7 @@
 
 #include "include/core/SkMatrix.h"
 #include "include/core/SkPath.h"
+#include "include/core/SkPathIter.h"
 #include "include/core/SkPathTypes.h"
 #include "include/core/SkPoint.h"
 #include "include/core/SkRect.h"
@@ -25,6 +26,7 @@
 #include <tuple>
 
 class SkRRect;
+struct SkPathRaw;
 
 class SK_API SkPathBuilder {
 public:
@@ -84,16 +86,18 @@ public:
     /** Returns an SkPath representing the current state of the SkPathBuilder. The builder is
         unchanged after returning the path.
 
+        @param mx if present, applied to the points after they are copied into the resulting path.
         @return  SkPath representing the current state of the builder.
      */
-    SkPath snapshot() const;
+    SkPath snapshot(const SkMatrix* mx = nullptr) const;
 
     /** Returns an SkPath representing the current state of the SkPathBuilder. The builder is
         reset to empty after returning the path.
 
+        @param mx if present, applied to the points after they are copied into the resulting path.
         @return  SkPath representing the current state of the builder.
      */
-    SkPath detach();
+    SkPath detach(const SkMatrix* mx = nullptr);
 
     /** Sets SkPathFillType, the rule used to fill SkPath. While there is no
         check that ft is legal, values outside of SkPathFillType are not supported.
@@ -129,20 +133,17 @@ public:
     */
     SkPathBuilder& reset();
 
-    /** Adds beginning of contour at SkPoint p.
-
-        @param p  contour start
-        @return   reference to SkPathBuilder
-    */
-    SkPathBuilder& moveTo(SkPoint pt);
-
-    /** Adds beginning of contour at SkPoint (x, y).
+    /** Specifies the beginning of contour. If the previous verb was a "move" verb,
+     *  then this just replaces the point value of that move, otherwise it appends a new
+     *  "move" verb to the builder using the point.
+     *
+     *  Thus, each contour can only have 1 move verb in it (the last one specified).
+     */
+    SkPathBuilder& moveTo(SkPoint point);
 
-        @param x  x-axis value of contour start
-        @param y  y-axis value of contour start
-        @return   reference to SkPathBuilder
-    */
-    SkPathBuilder& moveTo(SkScalar x, SkScalar y) { return this->moveTo(SkPoint::Make(x, y)); }
+    SkPathBuilder& moveTo(SkScalar x, SkScalar y) {
+        return this->moveTo(SkPoint::Make(x, y));
+    }
 
     /** Adds line from last point to SkPoint p. If SkPathBuilder is empty, or last SkPath::Verb is
         kClose_Verb, last point is set to (0, 0) before adding line.
@@ -356,6 +357,18 @@ public:
 
     // Relative versions of segments, relative to the previous position.
 
+    /** Adds beginning of contour relative to last point.
+        If SkPathBuilder is empty, starts contour at (dx, dy).
+        Otherwise, start contour at last point offset by (dx, dy).
+        Function name stands for "relative move to".
+
+        @param pt  vector offset from last point to contour start
+        @return    reference to SkPathBuilder
+
+        example: https://fiddle.skia.org/c/@Path_rMoveTo
+    */
+    SkPathBuilder& rMoveTo(SkPoint pt);
+
     /** Adds line from last point to vector given by pt. If SkPathBuilder is empty, or last
         SkPath::Verb is kClose_Verb, last point is set to (0, 0) before adding line.
 
@@ -635,6 +648,10 @@ public:
     */
     SkPathBuilder& addArc(const SkRect& oval, SkScalar startAngleDeg, SkScalar sweepAngleDeg);
 
+    SkPathBuilder& addLine(SkPoint a, SkPoint b) {
+        return this->moveTo(a).lineTo(b);
+    }
+
     /** Adds a new contour to the SkPathBuilder, defined by the rect, and wound in the
         specified direction. The verbs added to the path will be:
 
@@ -676,7 +693,7 @@ public:
         @param dir    SkPath::Direction to orient the new contour
         @return       reference to SkPathBuilder
      */
-    SkPathBuilder& addRect(const SkRect& rect, SkPathDirection dir = SkPathDirection::kCW) {
+    SkPathBuilder& addRect(const SkRect& rect, SkPathDirection dir = SkPathDirection::kDefault) {
         return this->addRect(rect, dir, 0);
     }
 
@@ -714,7 +731,7 @@ public:
         @param dir    SkPath::Direction to wind SkRRect
         @return       reference to SkPathBuilder
     */
-    SkPathBuilder& addRRect(const SkRRect& rrect, SkPathDirection dir = SkPathDirection::kCW) {
+    SkPathBuilder& addRRect(const SkRRect& rrect, SkPathDirection dir = SkPathDirection::kDefault) {
         // legacy start indices: 6 (CW) and 7 (CCW)
         return this->addRRect(rrect, dir, dir == SkPathDirection::kCW ? 6 : 7);
     }
@@ -730,7 +747,7 @@ public:
 
         example: https://fiddle.skia.org/c/@Path_addOval_2
     */
-    SkPathBuilder& addOval(const SkRect& oval, SkPathDirection dir = SkPathDirection::kCW) {
+    SkPathBuilder& addOval(const SkRect& oval, SkPathDirection dir = SkPathDirection::kDefault) {
         // legacy start index: 1
         return this->addOval(oval, dir, 1);
     }
@@ -748,7 +765,7 @@ public:
         @return        reference to SkPathBuilder
     */
     SkPathBuilder& addCircle(SkScalar x, SkScalar y, SkScalar radius,
-                             SkPathDirection dir = SkPathDirection::kCW);
+                             SkPathDirection dir = SkPathDirection::kDefault);
 
     /** Adds contour created from line array, adding (pts.size() - 1) line segments.
         Contour added starts at pts[0], then adds a line for every additional SkPoint
@@ -842,8 +859,18 @@ public:
         @param matrix  SkMatrix to apply to SkPath
         @param pc      whether to apply perspective clipping
     */
-    SkPathBuilder& transform(const SkMatrix& matrix,
-                             SkApplyPerspectiveClip pc = SkApplyPerspectiveClip::kYes);
+    SkPathBuilder& transform(const SkMatrix& matrix);
+
+#ifdef SK_SUPPORT_LEGACY_APPLYPERSPECTIVECLIP
+    SkPathBuilder& transform(const SkMatrix& matrix, SkApplyPerspectiveClip) {
+        return this->transform(matrix);
+    }
+#endif
+
+    /*
+     *  Returns true if the builder is empty, or all of its points are finite.
+     */
+    bool isFinite() const;
 
     /** Replaces SkPathFillType with its inverse. The inverse of SkPathFillType describes the area
         unmodified by the original SkPathFillType.
@@ -903,36 +930,37 @@ public:
     SkSpan<const SkPoint> points() const {
         return fPts;
     }
-    SkSpan<const uint8_t> verbs() const {
+    SkSpan<const SkPathVerb> verbs() const {
         return fVerbs;
     }
+    SkSpan<const float> conicWeights() const {
+        return fConicWeights;
+    }
+
+    SkPathBuilder& addRaw(const SkPathRaw&);
+
+    SkPathIter iter() const;
 
 private:
     SkPathRef::PointsArray fPts;
     SkPathRef::VerbsArray fVerbs;
     SkPathRef::ConicWeightsArray fConicWeights;
 
-    SkPathFillType      fFillType;
-    bool                fIsVolatile;
+    SkPathFillType  fFillType;
+    bool            fIsVolatile;
+    SkPathConvexity fConvexity;
 
     unsigned    fSegmentMask;
     SkPoint     fLastMovePoint;
     int         fLastMoveIndex; // only needed until SkPath is immutable
     bool        fNeedsMoveVerb;
 
-    enum IsA {
-        kIsA_JustMoves,     // we only have 0 or more moves
-        kIsA_MoreThanMoves, // we have verbs other than just move
-        kIsA_Oval,          // we are 0 or more moves followed by an oval
-        kIsA_RRect,         // we are 0 or more moves followed by a rrect
-    };
-    IsA fIsA      = kIsA_JustMoves;
-    int fIsAStart = -1;     // tracks direction iff fIsA is not unknown
-    bool fIsACCW  = false;  // tracks direction iff fIsA is not unknown
+    SkPathIsAType fType = SkPathIsAType::kGeneral;
+    SkPathIsAData fIsA {};
 
     // called right before we add a (non-move) verb
     void ensureMove() {
-        fIsA = kIsA_MoreThanMoves;
+        fType = SkPathIsAType::kGeneral;
         if (fNeedsMoveVerb) {
             this->moveTo(fLastMovePoint);
         }
@@ -948,6 +976,8 @@ private:
     std::tuple<SkPoint*, SkScalar*> growForVerbsInPath(const SkPathRef& path);
 
     friend class SkPathPriv;
+    friend class SkStroke;
+    friend class SkPathStroker;
 };
 
 #endif

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

@@ -10,7 +10,7 @@
 
 #include "include/core/SkFlattenable.h"
 #include "include/core/SkRefCnt.h"
-#include "include/private/base/SkAPI.h"
+#include "include/core/SkTypes.h"
 
 // TODO(kjlubick) update clients and remove this unnecessary #include
 #include "include/core/SkPath.h"  // IWYU pragma: keep
@@ -18,6 +18,7 @@
 #include <cstddef>
 
 class SkMatrix;
+class SkPathBuilder;
 class SkStrokeRec;
 struct SkDeserialProcs;
 struct SkRect;
@@ -68,11 +69,9 @@ public:
      *  If this method returns true, the caller will apply (as needed) the
      *  resulting stroke-rec to dst and then draw.
      */
-    bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect* cullR) const;
-
-    /** Version of filterPath that can be called when the CTM is known. */
-    bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect* cullR,
+    bool filterPath(SkPathBuilder* dst, const SkPath& src, SkStrokeRec*, const SkRect* cullR,
                     const SkMatrix& ctm) const;
+    bool filterPath(SkPathBuilder* dst, const SkPath& src, SkStrokeRec*) const;
 
     /** True if this path effect requires a valid CTM */
     bool needsCTM() const;
@@ -80,6 +79,14 @@ public:
     static sk_sp<SkPathEffect> Deserialize(const void* data, size_t size,
                                            const SkDeserialProcs* procs = nullptr);
 
+#ifdef SK_SUPPORT_MUTABLE_PATHEFFECT
+    bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect* cullR) const;
+
+    /** Version of filterPath that can be called when the CTM is known. */
+    bool filterPath(SkPath* dst, const SkPath& src, SkStrokeRec*, const SkRect* cullR,
+                    const SkMatrix& ctm) const;
+#endif
+
 private:
     SkPathEffect() = default;
     friend class SkPathEffectBase;

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

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2025 Google LLC.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkPathIter_DEFINED
+#define SkPathIter_DEFINED
+
+#include "include/core/SkPathTypes.h"
+#include "include/core/SkPoint.h"
+#include "include/core/SkSpan.h"
+
+#include <array>
+#include <cstddef>
+#include <optional>
+
+class SK_API SkPathIter {
+public:
+    struct Rec {
+        SkSpan<const SkPoint> fPoints;
+        float                 fConicWeight;
+        SkPathVerb            fVerb;
+
+        float conicWeight() const {
+            SkASSERT(fVerb == SkPathVerb::kConic);
+            return fConicWeight;
+        }
+    };
+
+    SkPathIter(SkSpan<const SkPoint> pts, SkSpan<const SkPathVerb> vbs, SkSpan<const float> cns)
+        : pIndex(0), vIndex(0), cIndex(0)
+        , fPoints(pts), fVerbs(vbs), fConics(cns)
+    {
+        // For compat older iterators, we trim off a trailing Move.
+        // SkPathData is defined to never create this pattern, so perhaps in the future
+        // this check can be removed (or replaced by an assert)
+        if (!vbs.empty() && vbs.back() == SkPathVerb::kMove) {
+            fVerbs = vbs.first(vbs.size() - 1);
+        }
+    }
+
+    /*  Holds the current verb, and its associated points
+     *  move:  pts[0]
+     *  line:  pts[0..1]
+     *  quad:  pts[0..2]
+     *  conic: pts[0..2] fConicWeight
+     *  cubic: pts[0..3]
+     *  close: pts[0..1] ... as if close were a line from pts[0] to pts[1]
+     */
+    std::optional<Rec> next();
+
+    std::optional<SkPathVerb> peekNextVerb() const {
+        if (vIndex < fVerbs.size()) {
+            return fVerbs[vIndex];
+        }
+        return {};
+    }
+
+private:
+    size_t                   pIndex, vIndex, cIndex;
+    SkSpan<const SkPoint>    fPoints;
+    SkSpan<const SkPathVerb> fVerbs;
+    SkSpan<const float>      fConics;
+    std::array<SkPoint, 2>   fClosePointStorage;
+};
+
+class SkPathContourIter {
+public:
+    struct Rec {
+        SkSpan<const SkPoint>    fPoints;
+        SkSpan<const SkPathVerb> fVerbs;
+        SkSpan<const float>      fConics;
+    };
+
+    SkPathContourIter(SkSpan<const SkPoint> pts, SkSpan<const SkPathVerb> vbs,
+                      SkSpan<const float> cns)
+        : fPoints(pts), fVerbs(vbs), fConics(cns)
+    {}
+
+    std::optional<Rec> next();
+
+private:
+    SkSpan<const SkPoint>    fPoints;
+    SkSpan<const SkPathVerb> fVerbs;
+    SkSpan<const float>      fConics;
+};
+
+#endif

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

@@ -12,11 +12,12 @@
 #include "include/core/SkPoint.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
-#include "include/private/base/SkAPI.h"
+#include "include/core/SkTypes.h"
 #include "include/private/base/SkDebug.h"
 
 class SkMatrix;
 class SkPath;
+class SkPathBuilder;
 
 class SK_API SkPathMeasure {
 public:
@@ -70,7 +71,10 @@ public:
         then return false (and leave dst untouched).
         Begin the segment with a moveTo if startWithMoveTo is true
     */
+    bool getSegment(SkScalar startD, SkScalar stopD, SkPathBuilder* dst, bool startWithMoveTo);
+#ifdef SK_SUPPORT_MUTABLE_PATHEFFECT
     bool getSegment(SkScalar startD, SkScalar stopD, SkPath* dst, bool startWithMoveTo);
+#endif
 
     /** Return true if the current contour is closed()
     */

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

@@ -12,7 +12,7 @@
 
 #include <cstdint>
 
-enum class SkPathFillType {
+enum class SkPathFillType : uint8_t {
     /** Specifies that "inside" is computed by a non-zero sum of signed edge crossings */
     kWinding,
     /** Specifies that "inside" is computed by an odd number of edge crossings */
@@ -20,7 +20,9 @@ enum class SkPathFillType {
     /** Same as Winding, but draws outside of the path, rather than inside */
     kInverseWinding,
     /** Same as EvenOdd, but draws outside of the path, rather than inside */
-    kInverseEvenOdd
+    kInverseEvenOdd,
+
+    kDefault = kWinding,
 };
 
 static inline bool SkPathFillType_IsEvenOdd(SkPathFillType ft) {
@@ -35,11 +37,13 @@ static inline SkPathFillType SkPathFillType_ConvertToNonInverse(SkPathFillType f
     return static_cast<SkPathFillType>(static_cast<int>(ft) & 1);
 }
 
-enum class SkPathDirection {
+enum class SkPathDirection : uint8_t {
     /** clockwise direction for adding closed contours */
     kCW,
     /** counter-clockwise direction for adding closed contours */
     kCCW,
+
+    kDefault = kCW,
 };
 
 enum SkPathSegmentMask {

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

@@ -7,28 +7,34 @@
 #ifndef SkPathUtils_DEFINED
 #define SkPathUtils_DEFINED
 
-#include "include/core/SkScalar.h"
+#include "include/core/SkScalar.h"  // IWYU pragma: keep
 #include "include/core/SkTypes.h"
 
 class SkMatrix;
 class SkPaint;
 class SkPath;
+class SkPathBuilder;
 struct SkRect;
 
 namespace skpathutils {
 
-/** Returns the filled equivalent of the stroked path.
-
-    @param src       SkPath read to create a filled version
-    @param paint     SkPaint, from which attributes such as stroke cap, width, miter, and join,
-                     as well as pathEffect will be used.
-    @param dst       resulting SkPath; may be the same as src, but may not be nullptr
-    @param cullRect  optional limit passed to SkPathEffect
-    @param resScale  if > 1, increase precision, else if (0 < resScale < 1) reduce precision
-                     to favor speed and size
-    @return          true if the dst path was updated, false if it was not (e.g. if the path
-                     represents hairline and cannot be filled).
-*/
+/* Returns the filled equivalent of the stroked path.
+ *
+ *  @param src       SkPath read to create a filled version
+ *  @param paint     uses settings for stroke cap, width, miter, join, and patheffect.
+ *  @param dst       results are written to this builder.
+ *  @param cullRect  optional limit passed to SkPathEffect
+ *  @param ctm       matrix to take into acount for increased precision (if it scales up).
+ *  @return          true if the result can be filled, or false if it is a hairline (to be stroked).
+ */
+SK_API bool FillPathWithPaint(const SkPath& src, const SkPaint& paint, SkPathBuilder* dst,
+                              const SkRect* cullRect, const SkMatrix& ctm);
+
+SK_API bool FillPathWithPaint(const SkPath& src, const SkPaint& paint, SkPathBuilder* dst);
+
+SK_API SkPath FillPathWithPaint(const SkPath& src, const SkPaint& paint, bool* isFill = nullptr);
+
+#ifdef SK_SUPPORT_MUTABLE_PATHEFFECT
 SK_API bool FillPathWithPaint(const SkPath &src, const SkPaint &paint, SkPath *dst,
                               const SkRect *cullRect, SkScalar resScale = 1);
 
@@ -36,6 +42,7 @@ SK_API bool FillPathWithPaint(const SkPath &src, const SkPaint &paint, SkPath *d
                               const SkRect *cullRect, const SkMatrix &ctm);
 
 SK_API bool FillPathWithPaint(const SkPath &src, const SkPaint &paint, SkPath *dst);
+#endif
 
 }
 

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

@@ -17,6 +17,7 @@
 
 #include <cstdint>
 #include <cstring>
+#include <optional>
 
 class SkMatrix;
 class SkString;
@@ -450,18 +451,13 @@ public:
     */
     size_t readFromMemory(const void* buffer, size_t length);
 
-    /** Transforms by SkRRect by matrix, storing result in dst.
-        Returns true if SkRRect transformed can be represented by another SkRRect.
-        Returns false if matrix contains transformations that are not axis aligned.
-
-        Asserts in debug builds if SkRRect equals dst.
-
-        @param matrix  SkMatrix specifying the transform
-        @param dst     SkRRect to store the result
-        @return        true if transformation succeeded.
+    /** Transforms by SkRRect by matrix and return it if possible.
+     *  If the matrix does not preserve axis-alignment (e.g. rotates, skews, etc.)
+     *  then this returns {}.
+     */
+    std::optional<SkRRect> transform(const SkMatrix&) const;
 
-        example: https://fiddle.skia.org/c/@RRect_transform
-    */
+    // Deprecated: use optional form
     bool transform(const SkMatrix& matrix, SkRRect* dst) const;
 
     /** Writes text representation of SkRRect to standard output.

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

@@ -9,6 +9,8 @@
 
 #include "include/private/base/SkAPI.h"
 
+class SkCanvas;
+
 namespace skcpu {
 class Recorder;
 }
@@ -30,6 +32,16 @@ public:
     virtual Type type() const = 0;
 
     virtual skcpu::Recorder* cpuRecorder() = 0;
+
+private:
+
+    /**
+    * Attempts to create and return an SkCaptureCanvas that wraps the provided base canvas.
+    * Returns nullptr if capture is not enabled.
+    */
+    virtual SkCanvas* makeCaptureCanvas(SkCanvas*) = 0;
+
+    friend class SkSurface_Base;
 };
 
 #endif

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

@@ -8,6 +8,7 @@
 #ifndef SkRect_DEFINED
 #define SkRect_DEFINED
 
+#include "include/core/SkPathTypes.h"
 #include "include/core/SkPoint.h"
 #include "include/core/SkSize.h"
 #include "include/core/SkSpan.h"
@@ -17,6 +18,7 @@
 #include "include/private/base/SkTFitsIn.h"
 
 #include <algorithm>
+#include <array>
 #include <cmath>
 #include <cstdint>
 #include <cstring>
@@ -832,16 +834,39 @@ struct SK_API SkRect {
         return !(a == b);
     }
 
-    /** Returns four points in quad that enclose SkRect ordered as: top-left, top-right,
-        bottom-right, bottom-left.
+    SkPoint TL() const { return {fLeft,  fTop}; }
+    SkPoint TR() const { return {fRight, fTop}; }
+    SkPoint BL() const { return {fLeft,  fBottom}; }
+    SkPoint BR() const { return {fRight, fBottom}; }
 
-        TODO: Consider adding parameter to control whether quad is clockwise or counterclockwise.
-
-        @param quad  storage for corners of SkRect
+    /** Returns four points in quad that enclose SkRect,
+     *  respect the specified path-direction.
+     */
+    std::array<SkPoint, 4> toQuad(SkPathDirection dir = SkPathDirection::kCW) const {
+        std::array<SkPoint, 4> storage;
+        this->copyToQuad(storage, dir);
+        return storage;
+    }
+
+    // Same as toQuad(), but copies the 4 points into the specified storage
+    // which must be at least a size of 4.
+    void copyToQuad(SkSpan<SkPoint> pts, SkPathDirection dir = SkPathDirection::kCW) const {
+        SkASSERT(pts.size() >= 4);
+        pts[0] = this->TL();
+        pts[2] = this->BR();
+        if (dir == SkPathDirection::kCW) {
+            pts[1] = this->TR();
+            pts[3] = this->BL();
+        } else {
+            pts[1] = this->BL();
+            pts[3] = this->TR();
+        }
+    }
 
-        example: https://fiddle.skia.org/c/@Rect_toQuad
-    */
-    void toQuad(SkPoint quad[4]) const;
+    // DEPRECATED: use std::array or copyToQuad versions
+    void toQuad(SkPoint quad[4]) const {
+        this->copyToQuad({quad, 4});
+    }
 
     /** Sets SkRect to (0, 0, 0, 0).
 

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

@@ -14,11 +14,13 @@
 #include "include/private/base/SkDebug.h"
 #include "include/private/base/SkTypeTraits.h"
 
+#include "include/core/SkPath.h"    // IWYU -- for SK_HIDE_PATH_EDIT_METHODS
+
 #include <cstddef>
 #include <cstdint>
 #include <type_traits>
 
-class SkPath;
+class SkPathBuilder;
 
 /** \class SkRegion
     SkRegion describes the set of pixels used to clip SkCanvas. SkRegion is compact,
@@ -177,7 +179,7 @@ public:
     */
     int computeRegionComplexity() const;
 
-    /** Appends outline of SkRegion to path.
+    /** Appends outline of SkRegion to path builder.
         Returns true if SkRegion is not empty; otherwise, returns false, and leaves path
         unmodified.
 
@@ -186,7 +188,16 @@ public:
 
         example: https://fiddle.skia.org/c/@Region_getBoundaryPath
     */
+    bool addBoundaryPath(SkPathBuilder*) const;
+
+    /**
+     * Return the boundary of the region as a path.
+     */
+    SkPath getBoundaryPath() const;
+
+#ifndef SK_HIDE_PATH_EDIT_METHODS
     bool getBoundaryPath(SkPath* path) const;
+#endif
 
     /** Constructs an empty SkRegion. SkRegion is set to empty bounds
         at (0, 0) with zero width and height. Always returns false.
@@ -560,7 +571,7 @@ public:
     /** \class SkRegion::Spanerator
         Returns the line segment ends within SkRegion that intersect a horizontal line.
     */
-    class Spanerator {
+    class SK_API Spanerator {
     public:
 
         /** Sets SkRegion::Spanerator to return line segments in SkRegion on scan line.

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

@@ -133,18 +133,6 @@ static inline SkScalar SkScalarInterp(SkScalar A, SkScalar B, SkScalar t) {
     return A + (B - A) * t;
 }
 
-/** Interpolate along the function described by (keys[length], values[length])
-    for the passed searchKey. SearchKeys outside the range keys[0]-keys[Length]
-    clamp to the min or max value. This function assumes the number of pairs
-    (length) will be small and a linear search is used.
-
-    Repeated keys are allowed for discontinuous functions (so long as keys is
-    monotonically increasing). If key is the value of a repeated scalar in
-    keys the first one will be used.
-*/
-SkScalar SkScalarInterpFunc(SkScalar searchKey, const SkScalar keys[],
-                            const SkScalar values[], int length);
-
 /*
  *  Helper to compare an array of scalars.
  */