@shopify/react-native-skia 2.3.0 → 2.3.4

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

@@ -9,6 +9,7 @@
 #define SkPath_DEFINED
 
 #include "include/core/SkMatrix.h"
+#include "include/core/SkPathIter.h"
 #include "include/core/SkPathTypes.h"
 #include "include/core/SkPoint.h"
 #include "include/core/SkRect.h"
@@ -26,13 +27,12 @@
 #include <optional>
 #include <tuple>
 
-struct SkArc;
 class SkData;
 class SkPathRef;
 class SkRRect;
 class SkWStream;
 enum class SkPathConvexity;
-enum class SkPathFirstDirection;
+struct SkPathRaw;
 struct SkPathVerbAnalysis;
 
 // WIP -- define this locally, and fix call-sites to use SkPathBuilder (skbug.com/40040287)
@@ -59,7 +59,7 @@ struct SkPathVerbAnalysis;
 class SK_API SkPath {
 public:
     /**
-     *  Create a new path with the specified segments.
+     *  Create a new path with the specified spans.
      *
      *  The points and weights arrays are read in order, based on the sequence of verbs.
      *
@@ -77,30 +77,40 @@ public:
      *  with a Move verb, followed by 0 or more segments: Line, Quad, Conic, Cubic, followed
      *  by an optional Close.
      */
-    static SkPath Make(SkSpan<const SkPoint> pts,
-                       SkSpan<const uint8_t> verbs,
-                       SkSpan<const SkScalar> conics,
-                       SkPathFillType, bool isVolatile = false);
+    static SkPath Raw(SkSpan<const SkPoint> pts,
+                      SkSpan<const SkPathVerb> verbs,
+                      SkSpan<const SkScalar> conics,
+                      SkPathFillType, bool isVolatile = false);
 
-    static SkPath Rect(const SkRect&, SkPathDirection = SkPathDirection::kCW,
+    static SkPath Rect(const SkRect&, SkPathDirection = SkPathDirection::kDefault,
                        unsigned startIndex = 0);
-    static SkPath Oval(const SkRect&, SkPathDirection = SkPathDirection::kCW);
+    static SkPath Oval(const SkRect&, SkPathDirection = SkPathDirection::kDefault);
     static SkPath Oval(const SkRect&, SkPathDirection, unsigned startIndex);
     static SkPath Circle(SkScalar center_x, SkScalar center_y, SkScalar radius,
                          SkPathDirection dir = SkPathDirection::kCW);
-    static SkPath RRect(const SkRRect&, SkPathDirection dir = SkPathDirection::kCW);
+    static SkPath RRect(const SkRRect&, SkPathDirection dir = SkPathDirection::kDefault);
     static SkPath RRect(const SkRRect&, SkPathDirection, unsigned startIndex);
     static SkPath RRect(const SkRect& bounds, SkScalar rx, SkScalar ry,
-                        SkPathDirection dir = SkPathDirection::kCW);
+                        SkPathDirection dir = SkPathDirection::kDefault);
 
     static SkPath Polygon(SkSpan<const SkPoint> pts, bool isClosed,
-                          SkPathFillType fillType = SkPathFillType::kWinding,
+                          SkPathFillType fillType = SkPathFillType::kDefault,
                           bool isVolatile = false);
 
     static SkPath Line(const SkPoint a, const SkPoint b) {
         return Polygon({a, b}, false);
     }
 
+    // Deprecated: use Raw()
+    static SkPath Make(SkSpan<const SkPoint> pts,
+                       SkSpan<const uint8_t> verbs,
+                       SkSpan<const SkScalar> conics,
+                       SkPathFillType fillType,
+                       bool isVolatile = false) {
+        return Raw(pts, {reinterpret_cast<const SkPathVerb*>(verbs.data()), verbs.size()},
+                   conics, fillType, isVolatile);
+    }
+
     /** Constructs an empty SkPath. By default, SkPath has no verbs, no SkPoint, and no weights.
         FillType is set to kWinding.
 
@@ -137,19 +147,6 @@ public:
         return *this;
     }
 
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-private:
-#endif
-    /** Returns a copy of this path in the current state, and resets the path to empty. */
-    SkPath detach() {
-        SkPath result = *this;
-        this->reset();
-        return result;
-    }
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-public:
-#endif
-
     /** Constructs a copy of an existing path.
         SkPath assignment makes two paths identical by value. Internally, assignment
         shares pointer values. The underlying verb array, SkPoint array and weights
@@ -200,9 +197,6 @@ public:
     */
     bool isInterpolatable(const SkPath& compare) const;
 
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-private:
-#endif
     /** Interpolates between SkPath with SkPoint array of equal size.
         Copy verb array and weights to out, and set out SkPoint array to a weighted
         average of this SkPoint array and ending SkPoint array, using the formula:
@@ -212,22 +206,17 @@ private:
         one (this Point_Array); will work with values outside of this
         range.
 
-        interpolate() returns false and leaves out unchanged if SkPoint array is not
-        the same size as ending SkPoint array. Call isInterpolatable() to check SkPath
-        compatibility prior to calling interpolate().
+        interpolate() returns an empty SkPath if SkPoint array is not the same size
+        as ending SkPoint array. Call isInterpolatable() to check SkPath compatibility
+        prior to calling makeInterpolate().
 
         @param ending  SkPoint array averaged with this SkPoint array
         @param weight  contribution of this SkPoint array, and
                        one minus contribution of ending SkPoint array
-        @param out     SkPath replaced by interpolated averages
-        @return        true if SkPath contain same number of SkPoint
+        @return        SkPath replaced by interpolated averages
 
         example: https://fiddle.skia.org/c/@Path_interpolate
     */
-    bool interpolate(const SkPath& ending, SkScalar weight, SkPath* out) const;
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-public:
-#endif
     SkPath makeInterpolate(const SkPath& ending, SkScalar weight) const;
 
     /** Returns SkPathFillType, the rule used to fill SkPath.
@@ -236,19 +225,6 @@ public:
     */
     SkPathFillType getFillType() const { return (SkPathFillType)fFillType; }
 
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-private:
-#endif
-    /** Sets SkPathFillType, the rule used to fill SkPath. While there is no
-        check that ft is legal, values outside of SkPathFillType are not supported.
-    */
-    void setFillType(SkPathFillType ft) {
-        fFillType = SkToU8(ft);
-    }
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-public:
-#endif
-
     /** Creates an SkPath with the same properties and data, and with SkPathFillType
         set to newFillType.
     */
@@ -261,19 +237,6 @@ public:
     */
     bool isInverseFillType() const { return SkPathFillType_IsInverse(this->getFillType()); }
 
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-private:
-#endif
-    /** Replaces SkPathFillType with its inverse. The inverse of SkPathFillType describes the area
-        unmodified by the original SkPathFillType.
-    */
-    void toggleInverseFillType() {
-        fFillType ^= 2;
-    }
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-public:
-#endif
-
     /** Creates an SkPath with the same properties and data, and with SkPathFillType
         replaced with its inverse.  The inverse of SkPathFillType describes the area unmodified
         by the original FillType.
@@ -311,45 +274,6 @@ 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;
-
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-private:
-#endif
-    /** 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.
-
-        @return  reference to SkPath
-
-        example: https://fiddle.skia.org/c/@Path_reset
-    */
-    SkPath& reset();
-
-    /** Sets SkPath to its initial state, preserving internal storage.
-        Removes verb array, SkPoint array, and weights, and sets FillType to kWinding.
-        Internal storage associated with SkPath is retained.
-
-        Use rewind() instead of reset() if SkPath storage will be reused and performance
-        is critical.
-
-        @return  reference to SkPath
-
-        example: https://fiddle.skia.org/c/@Path_rewind
-    */
-    SkPath& rewind();
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-public:
-#endif
-
     /** Returns if SkPath is empty.
         Empty SkPath may have FillType but has no SkPoint, SkPath::Verb, or conic weight.
         SkPath() constructs empty SkPath; reset() and rewind() make SkPath empty.
@@ -387,12 +311,9 @@ public:
         return SkToBool(fIsVolatile);
     }
 
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-private:
-#endif
-    /** Specifies whether SkPath is volatile; whether it will be altered or discarded
-        by the caller after it is drawn. SkPath by default have volatile set false, allowing
-        Skia to attach a cache of data which speeds repeated drawing.
+    /** Return a copy of SkPath with isVolatile indicating whether it will be altered
+        or discarded by the caller after it is drawn. SkPath by default have volatile
+        set false, allowing Skia to attach a cache of data which speeds repeated drawing.
 
         Mark temporary paths, discarded or modified after use, as volatile
         to inform Skia that the path need not be cached.
@@ -404,15 +325,8 @@ private:
         GPU surface SkPath draws are affected by volatile for some shadows and concave geometries.
 
         @param isVolatile  true if caller will alter SkPath after drawing
-        @return            reference to SkPath
+        @return            SkPath
     */
-    SkPath& setIsVolatile(bool isVolatile) {
-        fIsVolatile = isVolatile;
-        return *this;
-    }
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-public:
-#endif
     SkPath makeIsVolatile(bool isVolatile) const;
 
     /** Tests if line between SkPoint pair is degenerate.
@@ -528,26 +442,6 @@ public:
     */
     size_t approximateBytesUsed() const;
 
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-private:
-#endif
-    /** Exchanges the verb array, SkPoint array, weights, and SkPath::FillType with other.
-        Cached state is also exchanged. swap() internally exchanges pointers, so
-        it is lightweight and does not allocate memory.
-
-        swap() usage has largely been replaced by operator=(const SkPath& path).
-        SkPath do not copy their content on assignment until they are written to,
-        making assignment as efficient as swap().
-
-        @param other  SkPath exchanged by value
-
-        example: https://fiddle.skia.org/c/@Path_swap
-    */
-    void swap(SkPath& other);
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-public:
-#endif
-
     /** Returns minimum and maximum axes values of SkPoint array.
         Returns (0, 0, 0, 0) if SkPath contains no points. Returned bounds width and height may
         be larger or smaller than area affected when SkPath is drawn.
@@ -594,21 +488,290 @@ public:
     /** Returns true if rect is contained by SkPath.
         May return false when rect is contained by SkPath.
 
-        For now, only returns true if SkPath has one contour and is convex.
-        rect may share points and edges with SkPath and be contained.
-        Returns true if rect is empty, that is, it has zero width or height; and
-        the SkPoint or line described by rect is contained by SkPath.
+        For now, only returns true if SkPath has one contour and is convex.
+        rect may share points and edges with SkPath and be contained.
+        Returns true if rect is empty, that is, it has zero width or height; and
+        the SkPoint or line described by rect is contained by SkPath.
+
+        @param rect  SkRect, line, or SkPoint checked for containment
+        @return      true if rect is contained
+
+        example: https://fiddle.skia.org/c/@Path_conservativelyContainsRect
+    */
+    bool conservativelyContainsRect(const SkRect& rect) const;
+
+    /** \enum SkPath::ArcSize
+        Four oval parts with radii (rx, ry) start at last SkPath SkPoint and ends at (x, y).
+        ArcSize and Direction select one of the four oval parts.
+    */
+    enum ArcSize {
+        kSmall_ArcSize, //!< smaller of arc pair
+        kLarge_ArcSize, //!< larger of arc pair
+    };
+
+    /** Approximates conic with quad array. Conic is constructed from start SkPoint p0,
+        control SkPoint p1, end SkPoint p2, and weight w.
+        Quad array is stored in pts; this storage is supplied by caller.
+        Maximum quad count is 2 to the pow2.
+        Every third point in array shares last SkPoint of previous quad and first SkPoint of
+        next quad. Maximum pts storage size is given by:
+        (1 + 2 * (1 << pow2)) * sizeof(SkPoint).
+
+        Returns quad count used the approximation, which may be smaller
+        than the number requested.
+
+        conic weight determines the amount of influence conic control point has on the curve.
+        w less than one represents an elliptical section. w greater than one represents
+        a hyperbolic section. w equal to one represents a parabolic section.
+
+        Two quad curves are sufficient to approximate an elliptical conic with a sweep
+        of up to 90 degrees; in this case, set pow2 to one.
+
+        @param p0    conic start SkPoint
+        @param p1    conic control SkPoint
+        @param p2    conic end SkPoint
+        @param w     conic weight
+        @param pts   storage for quad array
+        @param pow2  quad count, as power of two, normally 0 to 5 (1 to 32 quad curves)
+        @return      number of quad curves written to pts
+    */
+    static int ConvertConicToQuads(const SkPoint& p0, const SkPoint& p1, const SkPoint& p2,
+                                   SkScalar w, SkPoint pts[], int pow2);
+
+    /** Returns true if SkPath is equivalent to SkRect when filled.
+        If false: rect, isClosed, and direction are unchanged.
+        If true: rect, isClosed, and direction are written to if not nullptr.
+
+        rect may be smaller than the SkPath bounds. SkPath bounds may include kMove_Verb points
+        that do not alter the area drawn by the returned rect.
+
+        @param rect       storage for bounds of SkRect; may be nullptr
+        @param isClosed   storage set to true if SkPath is closed; may be nullptr
+        @param direction  storage set to SkRect direction; may be nullptr
+        @return           true if SkPath contains SkRect
+
+        example: https://fiddle.skia.org/c/@Path_isRect
+    */
+    bool isRect(SkRect* rect, bool* isClosed = nullptr, SkPathDirection* direction = nullptr) const;
+
+    /** \enum SkPath::AddPathMode
+        AddPathMode chooses how addPath() appends. Adding one SkPath to another can extend
+        the last contour or start a new contour.
+    */
+    enum AddPathMode {
+        /** Contours are appended to the destination path as new contours.
+        */
+        kAppend_AddPathMode,
+        /** Extends the last contour of the destination path with the first countour
+            of the source path, connecting them with a line.  If the last contour is
+            closed, a new empty contour starting at its start point is extended instead.
+            If the destination path is empty, the result is the source path.
+            The last path of the result is closed only if the last path of the source is.
+        */
+        kExtend_AddPathMode,
+    };
+
+    /** Returns SkPath with SkPoint array offset by (dx, dy).
+
+        @param dx  offset added to SkPoint array x-axis coordinates
+        @param dy  offset added to SkPoint array y-axis coordinates
+    */
+    SkPath makeOffset(SkScalar dx, SkScalar dy) const {
+        SkPath dst;
+        this->offset(dx, dy, &dst);
+        return dst;
+    }
+
+    /** Return a copy of SkPath with verb array, SkPoint array, and weight transformed
+        by matrix. makeTransform may change verbs and increase their number.
+
+        @param matrix  SkMatrix to apply to SkPath
+        @param pc      whether to apply perspective clipping
+        @return        SkPath
+    */
+    SkPath makeTransform(const SkMatrix& matrix) const {
+        SkPath dst;
+        this->transform(matrix, &dst);
+        return dst;
+    }
+
+    SkPath makeScale(SkScalar sx, SkScalar sy) const {
+        return this->makeTransform(SkMatrix::Scale(sx, sy));
+    }
+
+#ifdef SK_SUPPORT_LEGACY_APPLYPERSPECTIVECLIP
+    void transform(const SkMatrix& matrix, SkPath* dst, SkApplyPerspectiveClip) const {
+        this->transform(matrix, dst);
+    }
+    void transform(const SkMatrix& matrix, SkApplyPerspectiveClip) {
+        this->transform(matrix);
+    }
+    SkPath makeTransform(const SkMatrix& m, SkApplyPerspectiveClip) const {
+        return this->makeTransform(m);
+    }
+#endif
+
+    /** Return the last point, or {}
+
+        @return The last if the path contains one or more SkPoint, else returns {}
+
+        example: https://fiddle.skia.org/c/@Path_getLastPt
+    */
+    std::optional<SkPoint> getLastPt() const;
+
+    // DEPRECATED
+    bool getLastPt(SkPoint* lastPt) const {
+        if (auto lp = this->getLastPt()) {
+            if (lastPt) {
+                *lastPt = *lp;
+            }
+            return true;
+        }
+        if (lastPt) {
+            *lastPt = {0, 0};
+        }
+        return false;
+    }
+
+    /** \enum SkPath::SegmentMask
+        SegmentMask constants correspond to each drawing Verb type in SkPath; for
+        instance, if SkPath only contains lines, only the kLine_SegmentMask bit is set.
+    */
+    enum SegmentMask {
+        kLine_SegmentMask  = kLine_SkPathSegmentMask,
+        kQuad_SegmentMask  = kQuad_SkPathSegmentMask,
+        kConic_SegmentMask = kConic_SkPathSegmentMask,
+        kCubic_SegmentMask = kCubic_SkPathSegmentMask,
+    };
+
+    /** Returns a mask, where each set bit corresponds to a SegmentMask constant
+        if SkPath contains one or more verbs of that type.
+        Returns zero if SkPath contains no lines, or curves: quads, conics, or cubics.
+
+        getSegmentMasks() returns a cached result; it is very fast.
+
+        @return  SegmentMask bits or zero
+    */
+    uint32_t getSegmentMasks() const;
+
+    /** \enum SkPath::Verb
+        Verb instructs SkPath how to interpret one or more SkPoint and optional conic weight;
+        manage contour, and terminate SkPath.
+    */
+    enum Verb {
+        kMove_Verb  = static_cast<int>(SkPathVerb::kMove),
+        kLine_Verb  = static_cast<int>(SkPathVerb::kLine),
+        kQuad_Verb  = static_cast<int>(SkPathVerb::kQuad),
+        kConic_Verb = static_cast<int>(SkPathVerb::kConic),
+        kCubic_Verb = static_cast<int>(SkPathVerb::kCubic),
+        kClose_Verb = static_cast<int>(SkPathVerb::kClose),
+        kDone_Verb  = kClose_Verb + 1
+    };
+
+    /** Specifies whether SkPath is volatile; whether it will be altered or discarded
+        by the caller after it is drawn. SkPath by default have volatile set false, allowing
+        Skia to attach a cache of data which speeds repeated drawing.
+
+        Mark temporary paths, discarded or modified after use, as volatile
+        to inform Skia that the path need not be cached.
+
+        Mark animating SkPath volatile to improve performance.
+        Mark unchanging SkPath non-volatile to improve repeated rendering.
+
+        raster surface SkPath draws are affected by volatile for some shadows.
+        GPU surface SkPath draws are affected by volatile for some shadows and concave geometries.
+
+        @param isVolatile  true if caller will alter SkPath after drawing
+        @return            reference to SkPath
+    */
+    SkPath& setIsVolatile(bool isVolatile) {
+        fIsVolatile = isVolatile;
+        return *this;
+    }
+
+    /** Exchanges the verb array, SkPoint array, weights, and SkPath::FillType with other.
+        Cached state is also exchanged. swap() internally exchanges pointers, so
+        it is lightweight and does not allocate memory.
+
+        swap() usage has largely been replaced by operator=(const SkPath& path).
+        SkPath do not copy their content on assignment until they are written to,
+        making assignment as efficient as swap().
+
+        @param other  SkPath exchanged by value
+
+        example: https://fiddle.skia.org/c/@Path_swap
+    */
+    void swap(SkPath& other);
+
+    /** Interpolates between SkPath with SkPoint array of equal size.
+        Copy verb array and weights to out, and set out SkPoint array to a weighted
+        average of this SkPoint array and ending SkPoint array, using the formula:
+        (Path Point * weight) + ending Point * (1 - weight).
+
+        weight is most useful when between zero (ending SkPoint array) and
+        one (this Point_Array); will work with values outside of this
+        range.
+
+        interpolate() returns false and leaves out unchanged if SkPoint array is not
+        the same size as ending SkPoint array. Call isInterpolatable() to check SkPath
+        compatibility prior to calling interpolate().
+
+        @param ending  SkPoint array averaged with this SkPoint array
+        @param weight  contribution of this SkPoint array, and
+                       one minus contribution of ending SkPoint array
+        @param out     SkPath replaced by interpolated averages
+        @return        true if SkPath contain same number of SkPoint
+
+        example: https://fiddle.skia.org/c/@Path_interpolate
+    */
+    bool interpolate(const SkPath& ending, SkScalar weight, SkPath* out) const;
+
+    /** Sets SkPathFillType, the rule used to fill SkPath. While there is no
+        check that ft is legal, values outside of SkPathFillType are not supported.
+    */
+    void setFillType(SkPathFillType ft) {
+        fFillType = SkToU8(ft);
+    }
+
+    /** Replaces SkPathFillType with its inverse. The inverse of SkPathFillType describes the area
+        unmodified by the original SkPathFillType.
+    */
+    void toggleInverseFillType() {
+        fFillType ^= 2;
+    }
+
+#ifdef SK_HIDE_PATH_EDIT_METHODS
+private:
+#endif
+    /** Returns a copy of this path in the current state, and resets the path to empty. */
+    SkPath detach() {
+        SkPath result = *this;
+        this->reset();
+        return result;
+    }
+
+    /** 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.
+
+        @return  reference to SkPath
+
+        example: https://fiddle.skia.org/c/@Path_reset
+    */
+    SkPath& reset();
+
+    /** Sets SkPath to its initial state, preserving internal storage.
+        Removes verb array, SkPoint array, and weights, and sets FillType to kWinding.
+        Internal storage associated with SkPath is retained.
+
+        Use rewind() instead of reset() if SkPath storage will be reused and performance
+        is critical.
 
-        @param rect  SkRect, line, or SkPoint checked for containment
-        @return      true if rect is contained
+        @return  reference to SkPath
 
-        example: https://fiddle.skia.org/c/@Path_conservativelyContainsRect
+        example: https://fiddle.skia.org/c/@Path_rewind
     */
-    bool conservativelyContainsRect(const SkRect& rect) const;
-
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-private:
-#endif
+    SkPath& rewind();
 
     /** Grows SkPath verb array, SkPoint array, and conics to contain additional space.
         May improve performance and use less memory by
@@ -622,24 +785,16 @@ private:
     */
     void incReserve(int extraPtCount, int extraVerbCount = 0, int extraConicCount = 0);
 
-    /** Adds beginning of contour at SkPoint (x, y).
-
-        @param x  x-axis value of contour start
-        @param y  y-axis value of contour start
-        @return   reference to SkPath
-
-        example: https://fiddle.skia.org/c/@Path_moveTo
-    */
-    SkPath& moveTo(SkScalar x, SkScalar y);
-
-    /** Adds beginning of contour at SkPoint p.
-
-        @param p  contour start
-        @return   reference to SkPath
-    */
-    SkPath& moveTo(const SkPoint& p) {
+    /** 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 path using the point.
+     *
+     *  Thus, each contour can only have 1 move verb in it (the last one specified).
+     */
+    SkPath& moveTo(SkPoint p) {
         return this->moveTo(p.fX, p.fY);
     }
+    SkPath& moveTo(SkScalar x, SkScalar y);
 
     /** Adds beginning of contour relative to last point.
         If SkPath is empty, starts contour at (dx, dy).
@@ -962,15 +1117,6 @@ private:
         return this->arcTo(p1.fX, p1.fY, p2.fX, p2.fY, radius);
     }
 
-    /** \enum SkPath::ArcSize
-        Four oval parts with radii (rx, ry) start at last SkPath SkPoint and ends at (x, y).
-        ArcSize and Direction select one of the four oval parts.
-    */
-    enum ArcSize {
-        kSmall_ArcSize, //!< smaller of arc pair
-        kLarge_ArcSize, //!< larger of arc pair
-    };
-
     /** Appends arc to SkPath. Arc is implemented by one or more conics weighted to
         describe part of oval with radii (rx, ry) rotated by xAxisRotate degrees. Arc
         curves from last SkPath SkPoint to (x, y), choosing one of four possible routes:
@@ -1069,59 +1215,6 @@ private:
     */
     SkPath& close();
 
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-public:
-#endif
-
-    /** Approximates conic with quad array. Conic is constructed from start SkPoint p0,
-        control SkPoint p1, end SkPoint p2, and weight w.
-        Quad array is stored in pts; this storage is supplied by caller.
-        Maximum quad count is 2 to the pow2.
-        Every third point in array shares last SkPoint of previous quad and first SkPoint of
-        next quad. Maximum pts storage size is given by:
-        (1 + 2 * (1 << pow2)) * sizeof(SkPoint).
-
-        Returns quad count used the approximation, which may be smaller
-        than the number requested.
-
-        conic weight determines the amount of influence conic control point has on the curve.
-        w less than one represents an elliptical section. w greater than one represents
-        a hyperbolic section. w equal to one represents a parabolic section.
-
-        Two quad curves are sufficient to approximate an elliptical conic with a sweep
-        of up to 90 degrees; in this case, set pow2 to one.
-
-        @param p0    conic start SkPoint
-        @param p1    conic control SkPoint
-        @param p2    conic end SkPoint
-        @param w     conic weight
-        @param pts   storage for quad array
-        @param pow2  quad count, as power of two, normally 0 to 5 (1 to 32 quad curves)
-        @return      number of quad curves written to pts
-    */
-    static int ConvertConicToQuads(const SkPoint& p0, const SkPoint& p1, const SkPoint& p2,
-                                   SkScalar w, SkPoint pts[], int pow2);
-
-    /** Returns true if SkPath is equivalent to SkRect when filled.
-        If false: rect, isClosed, and direction are unchanged.
-        If true: rect, isClosed, and direction are written to if not nullptr.
-
-        rect may be smaller than the SkPath bounds. SkPath bounds may include kMove_Verb points
-        that do not alter the area drawn by the returned rect.
-
-        @param rect       storage for bounds of SkRect; may be nullptr
-        @param isClosed   storage set to true if SkPath is closed; may be nullptr
-        @param direction  storage set to SkRect direction; may be nullptr
-        @return           true if SkPath contains SkRect
-
-        example: https://fiddle.skia.org/c/@Path_isRect
-    */
-    bool isRect(SkRect* rect, bool* isClosed = nullptr, SkPathDirection* direction = nullptr) const;
-
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-private:
-#endif
-
     /** Adds a new contour to the path, defined by the rect, and wound in the
         specified direction. The verbs added to the path will be:
 
@@ -1296,23 +1389,6 @@ private:
     */
     SkPath& addPoly(SkSpan<const SkPoint> pts, bool close);
 
-    /** \enum SkPath::AddPathMode
-        AddPathMode chooses how addPath() appends. Adding one SkPath to another can extend
-        the last contour or start a new contour.
-    */
-    enum AddPathMode {
-        /** Contours are appended to the destination path as new contours.
-        */
-        kAppend_AddPathMode,
-        /** Extends the last contour of the destination path with the first countour
-            of the source path, connecting them with a line.  If the last contour is
-            closed, a new empty contour starting at its start point is extended instead.
-            If the destination path is empty, the result is the source path.
-            The last path of the result is closed only if the last path of the source is.
-        */
-        kExtend_AddPathMode,
-    };
-
     /** Appends src to SkPath, offset by (dx, dy).
 
         If mode is kAppend_AddPathMode, src verb array, SkPoint array, and conic weights are
@@ -1369,17 +1445,6 @@ private:
     */
     SkPath& reverseAddPath(const SkPath& src);
 
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-public:
-#endif
-    SkPath makeOffset(SkScalar dx, SkScalar dy) const {
-        SkPath dst;
-        this->offset(dx, dy, &dst);
-        return dst;
-    }
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-private:
-#endif
     /** Offsets SkPoint array by (dx, dy). Offset SkPath replaces dst.
         If dst is nullptr, SkPath is replaced by offset data.
 
@@ -1412,8 +1477,7 @@ private:
 
         example: https://fiddle.skia.org/c/@Path_transform
     */
-    void transform(const SkMatrix& matrix, SkPath* dst,
-                   SkApplyPerspectiveClip pc = SkApplyPerspectiveClip::kYes) const;
+    void transform(const SkMatrix& matrix, SkPath* dst) const;
 
     /** Transforms verb array, SkPoint array, and weight by matrix.
         transform may change verbs and increase their number.
@@ -1422,39 +1486,11 @@ private:
         @param matrix  SkMatrix to apply to SkPath
         @param pc      whether to apply perspective clipping
     */
-    SkPath& transform(const SkMatrix& matrix,
-                      SkApplyPerspectiveClip pc = SkApplyPerspectiveClip::kYes) {
-        this->transform(matrix, this, pc);
+    SkPath& transform(const SkMatrix& matrix) {
+        this->transform(matrix, this);
         return *this;
     }
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-public:
-#endif
-
-    SkPath makeTransform(const SkMatrix& m,
-                         SkApplyPerspectiveClip pc = SkApplyPerspectiveClip::kYes) const {
-        SkPath dst;
-        this->transform(m, &dst, pc);
-        return dst;
-    }
-
-    SkPath makeScale(SkScalar sx, SkScalar sy) const {
-        return this->makeTransform(SkMatrix::Scale(sx, sy), SkApplyPerspectiveClip::kNo);
-    }
-
-    /** Returns last point on SkPath in lastPt. Returns false if SkPoint array is empty,
-        storing (0, 0) if lastPt is not nullptr.
-
-        @param lastPt  storage for final SkPoint in SkPoint array; may be nullptr
-        @return        true if SkPoint array contains one or more SkPoint
-
-        example: https://fiddle.skia.org/c/@Path_getLastPt
-    */
-    bool getLastPt(SkPoint* lastPt) const;
 
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-private:
-#endif
     /** Sets last point to (x, y). If SkPoint array is empty, append kMove_Verb to
         verb array and append (x, y) to SkPoint array.
 
@@ -1473,44 +1509,51 @@ private:
     void setLastPt(const SkPoint& p) {
         this->setLastPt(p.fX, p.fY);
     }
+
 #ifdef SK_HIDE_PATH_EDIT_METHODS
 public:
+#endif
+#ifdef SK_SUPPORT_UNSPANNED_APIS
+    static SkPath Make(const SkPoint points[], int pointCount,
+                       const uint8_t verbs[], int verbCount,
+                       const SkScalar conics[], int conicWeightCount,
+                       SkPathFillType fillType, bool isVolatile = false) {
+        return Make({points, pointCount},
+                    {verbs, verbCount},
+                    {conics, conicWeightCount},
+                    fillType, isVolatile);
+    }
+    static SkPath Polygon(const SkPoint pts[], int count, bool isClosed,
+                          SkPathFillType fillType = SkPathFillType::kWinding,
+                          bool isVolatile = false) {
+        return Polygon({pts, count}, isClosed, fillType, isVolatile);
+    }
+    int getPoints(SkPoint points[], int max) const {
+        return (int)this->getPoints({points, max});
+    }
+    int getVerbs(uint8_t verbs[], int max) const {
+        return (int)this->getVerbs({verbs, max});
+    }
+    SkPath& addRoundRect(const SkRect& rect, const SkScalar radii[],
+                         SkPathDirection dir = SkPathDirection::kCW) {
+        return this->addRoundRect(rect, {radii, radii ? 8 : 0}, dir);
+    }
+    SkPath& addPoly(const SkPoint pts[], int count, bool close) {
+        return this->addPoly({pts, count}, close);
+    }
 #endif
 
+    SkPathIter iter() const;
 
-    /** \enum SkPath::SegmentMask
-        SegmentMask constants correspond to each drawing Verb type in SkPath; for
-        instance, if SkPath only contains lines, only the kLine_SegmentMask bit is set.
-    */
-    enum SegmentMask {
-        kLine_SegmentMask  = kLine_SkPathSegmentMask,
-        kQuad_SegmentMask  = kQuad_SkPathSegmentMask,
-        kConic_SegmentMask = kConic_SkPathSegmentMask,
-        kCubic_SegmentMask = kCubic_SkPathSegmentMask,
-    };
-
-    /** Returns a mask, where each set bit corresponds to a SegmentMask constant
-        if SkPath contains one or more verbs of that type.
-        Returns zero if SkPath contains no lines, or curves: quads, conics, or cubics.
-
-        getSegmentMasks() returns a cached result; it is very fast.
-
-        @return  SegmentMask bits or zero
-    */
-    uint32_t getSegmentMasks() const;
+    struct IterRec {
+        SkPathVerb            fVerb;
+        SkSpan<const SkPoint> fPoints;
+        float                 fConicWeight;
 
-    /** \enum SkPath::Verb
-        Verb instructs SkPath how to interpret one or more SkPoint and optional conic weight;
-        manage contour, and terminate SkPath.
-    */
-    enum Verb {
-        kMove_Verb  = static_cast<int>(SkPathVerb::kMove),
-        kLine_Verb  = static_cast<int>(SkPathVerb::kLine),
-        kQuad_Verb  = static_cast<int>(SkPathVerb::kQuad),
-        kConic_Verb = static_cast<int>(SkPathVerb::kConic),
-        kCubic_Verb = static_cast<int>(SkPathVerb::kCubic),
-        kClose_Verb = static_cast<int>(SkPathVerb::kClose),
-        kDone_Verb  = kClose_Verb + 1
+        float conicWeight() const {
+            SkASSERT(fVerb == SkPathVerb::kConic);
+            return fConicWeight;
+        }
     };
 
     /** \class SkPath::Iter
@@ -1566,6 +1609,8 @@ public:
         */
         Verb next(SkPoint pts[4]);
 
+        std::optional<IterRec> next();
+
         /** Returns conic weight if next() returned kConic_Verb.
 
             If next() has not been called, or next() did not return kConic_Verb,
@@ -1597,49 +1642,20 @@ public:
         bool isClosedContour() const;
 
     private:
-        const SkPoint*  fPts;
-        const uint8_t*  fVerbs;
-        const uint8_t*  fVerbStop;
-        const SkScalar* fConicWeights;
-        SkPoint         fMoveTo;
-        SkPoint         fLastPt;
-        bool            fForceClose;
-        bool            fNeedClose;
-        bool            fCloseLine;
-
-        Verb autoClose(SkPoint pts[2]);
+        const SkPoint*          fPts;
+        const SkPathVerb*       fVerbs;
+        const SkPathVerb*       fVerbStop;
+        const SkScalar*         fConicWeights;
+        SkPoint                 fMoveTo;
+        SkPoint                 fLastPt;
+        std::array<SkPoint, 4>  fStorage;
+        bool                    fForceClose;
+        bool                    fNeedClose;
+        bool                    fCloseLine;
+
+        SkPathVerb autoClose(SkPoint pts[2]);
     };
 
-#ifdef SK_SUPPORT_UNSPANNED_APIS
-    static SkPath Make(const SkPoint points[], int pointCount,
-                       const uint8_t verbs[], int verbCount,
-                       const SkScalar conics[], int conicWeightCount,
-                       SkPathFillType fillType, bool isVolatile = false) {
-        return Make({points, pointCount},
-                    {verbs, verbCount},
-                    {conics, conicWeightCount},
-                    fillType, isVolatile);
-    }
-    static SkPath Polygon(const SkPoint pts[], int count, bool isClosed,
-                          SkPathFillType fillType = SkPathFillType::kWinding,
-                          bool isVolatile = false) {
-        return Polygon({pts, count}, isClosed, fillType, isVolatile);
-    }
-    int getPoints(SkPoint points[], int max) const {
-        return (int)this->getPoints({points, max});
-    }
-    int getVerbs(uint8_t verbs[], int max) const {
-        return (int)this->getVerbs({verbs, max});
-    }
-    SkPath& addRoundRect(const SkRect& rect, const SkScalar radii[],
-                         SkPathDirection dir = SkPathDirection::kCW) {
-        return this->addRoundRect(rect, {radii, radii ? 8 : 0}, dir);
-    }
-    SkPath& addPoly(const SkPoint pts[], int count, bool close) {
-        return this->addPoly({pts, count}, close);
-    }
-#endif
-
 private:
     /** \class SkPath::RangeIter
         Iterates through a raw range of path verbs, points, and conics. All values are returned
@@ -1650,7 +1666,7 @@ private:
     class RangeIter {
     public:
         RangeIter() = default;
-        RangeIter(const uint8_t* verbs, const SkPoint* points, const SkScalar* weights)
+        RangeIter(const SkPathVerb* verbs, const SkPoint* points, const SkScalar* weights)
                 : fVerb(verbs), fPoints(points), fWeights(weights) {
             SkDEBUGCODE(fInitialPoints = fPoints;)
         }
@@ -1661,7 +1677,7 @@ private:
             return fVerb == that.fVerb;
         }
         RangeIter& operator++() {
-            auto verb = static_cast<SkPathVerb>(*fVerb++);
+            auto verb = *fVerb++;
             fPoints += pts_advance_after_verb(verb);
             if (verb == SkPathVerb::kConic) {
                 ++fWeights;
@@ -1674,7 +1690,7 @@ private:
             return copy;
         }
         SkPathVerb peekVerb() const {
-            return static_cast<SkPathVerb>(*fVerb);
+            return *fVerb;
         }
         std::tuple<SkPathVerb, const SkPoint*, const SkScalar*> operator*() const {
             SkPathVerb verb = this->peekVerb();
@@ -1708,7 +1724,7 @@ private:
             }
             SkUNREACHABLE;
         }
-        const uint8_t* fVerb = nullptr;
+        const SkPathVerb* fVerb = nullptr;
         const SkPoint* fPoints = nullptr;
         const SkScalar* fWeights = nullptr;
         SkDEBUGCODE(const SkPoint* fInitialPoints = nullptr;)
@@ -1753,6 +1769,8 @@ public:
         */
         Verb next(SkPoint[4]);
 
+        std::optional<IterRec> next();
+
         /** Returns next SkPath::Verb, but does not advance RawIter.
 
             @return  next SkPath::Verb from verb array
@@ -1839,29 +1857,7 @@ public:
     */
     sk_sp<SkData> serialize() const;
 
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-private:
-#endif
-    /** Initializes SkPath from buffer of size length. Returns zero if the buffer is
-        data is inconsistent, or the length is too small.
-
-        Reads SkPath::FillType, verb array, SkPoint array, conic weight, and
-        additionally reads computed information like SkPath::Convexity and bounds.
-
-        Used only in concert with writeToMemory();
-        the format used for SkPath in memory is not guaranteed.
-
-        @param buffer  storage for SkPath
-        @param length  buffer size in bytes; must be multiple of 4
-        @return        number of bytes read, or zero on failure
-
-        example: https://fiddle.skia.org/c/@Path_readFromMemory
-    */
-    size_t readFromMemory(const void* buffer, size_t length);
-#ifdef SK_HIDE_PATH_EDIT_METHODS
-public:
-#endif
-    /** Initializes SkPath from buffer of size length. If the buffer data is inconsistent, or the
+    /** Returns a SkPath from buffer of size length. If the buffer data is inconsistent, or the
         length is too small, returns a nullopt.
 
         Reads SkPath::FillType, verb array, SkPoint array, conic weight, and
@@ -1880,6 +1876,10 @@ public:
     static std::optional<SkPath> ReadFromMemory(const void* buffer, size_t length,
                                                 size_t* bytesRead = nullptr);
 
+#ifndef SK_HIDE_PATH_EDIT_METHODS
+    size_t readFromMemory(const void* buffer, size_t length);
+#endif
+
     /** (See skbug.com/40032862)
         Returns a non-zero, globally unique value. A different value is returned
         if verb array, SkPoint array, or conic weight changes.
@@ -1906,13 +1906,11 @@ public:
     using sk_is_trivially_relocatable = std::true_type;
 
 private:
-    SkPath(sk_sp<SkPathRef>, SkPathFillType, bool isVolatile, SkPathConvexity,
-           SkPathFirstDirection firstDirection);
+    SkPath(sk_sp<SkPathRef>, SkPathFillType, bool isVolatile, SkPathConvexity);
 
     sk_sp<SkPathRef>               fPathRef;
     int                            fLastMoveToIndex;
     mutable std::atomic<uint8_t>   fConvexity;      // SkPathConvexity
-    mutable std::atomic<uint8_t>   fFirstDirection; // SkPathFirstDirection
     uint8_t                        fFillType    : 2;
     uint8_t                        fIsVolatile  : 1;
 
@@ -1982,8 +1980,7 @@ private:
     // Notice the setters are const... these are mutable atomic fields.
     void setConvexity(SkPathConvexity) const;
 
-    void setFirstDirection(SkPathFirstDirection) const;
-    SkPathFirstDirection getFirstDirection() const;
+    void addRaw(const SkPathRaw&);
 
     /** Returns the comvexity type, computing if needed. Never returns kUnknown.
         @return  path's convexity type (convex or concave)
@@ -2015,15 +2012,13 @@ private:
     // SkPathPriv::AnalyzeVerbs().
     static SkPath MakeInternal(const SkPathVerbAnalysis& analsis,
                                const SkPoint points[],
-                               const uint8_t verbs[],
-                               int verbCount,
+                               SkSpan<const SkPathVerb> verbs,
                                const SkScalar conics[],
                                SkPathFillType fillType,
                                bool isVolatile);
 
-    friend class SkAutoPathBoundsUpdate;
+    friend class SkAutoAddSimpleShape;
     friend class SkAutoDisableOvalCheck;
-    friend class SkAutoDisableDirectionCheck;
     friend class SkPathBuilder;
     friend class SkPathEdgeIter;
     friend class SkPathWriter;