@shopify/react-native-skia 2.3.0 → 2.3.4

package/cpp/skia/include/private/SkPathRef.h

@@ -9,8 +9,10 @@
 #define SkPathRef_DEFINED
 
 #include "include/core/SkArc.h"
+#include "include/core/SkMatrix.h"
 #include "include/core/SkPathTypes.h" // IWYU pragma: keep
 #include "include/core/SkPoint.h"
+#include "include/core/SkRRect.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
@@ -27,7 +29,63 @@
 #include <tuple>
 
 class SkMatrix;
-class SkRRect;
+
+/*
+ *  These "info" structs are used to return identifying information, when a path
+ *  is queried if it is a special "shape". (e.g. isOval(), isRRect())
+ */
+
+struct SkPathRectInfo {
+    SkRect          fRect;
+    SkPathDirection fDirection;
+    uint8_t         fStartIndex;
+};
+
+struct SkPathOvalInfo {
+    SkRect          fBounds;
+    SkPathDirection fDirection;
+    uint8_t         fStartIndex;
+};
+
+struct SkPathRRectInfo {
+    SkRRect         fRRect;
+    SkPathDirection fDirection;
+    uint8_t         fStartIndex;
+};
+
+/*
+ *  Paths can be tagged with a "Type" -- the IsAType
+ *  This signals that it was built from a high-level shape: oval, rrect, arc, wedge.
+ *  We try to retain this tag, but still build the explicitly line/quad/conic/cubic
+ *  structure need to represent that shape. Thus a user of path can always just look
+ *  at the points and verbs, and draw it correctly.
+ *
+ *  The GPU backend sometimes will sniff the path for this tag/type, and may have a
+ *  more optimal way to draw the shape if they know its "really" an oval or whatever.
+ *
+ *  Path's can also identify as a "rect" -- but we don't store any special tag for this.
+ *
+ *  Here are the special "types" we have APIs for (e.g. isRRect()) and what we store:
+ *
+ *      kGeneral  : no identifying shape, no extra data
+ *      (Rect)    : no tag, but isRect() will examing the points/verbs, and try to
+ *                  deduce that it represents a rect.
+ *      kOval     : the path bounds is also the oval's bounds -- we store the direction
+ *                  and start_index (important for dashing). see SkPathMakers.h
+ *      kRRect    : same as kOval for implicit bounds, direction and start_index.
+ *                  Note: we don't store its radii -- we deduce those when isRRect() is
+ *                        called, by examining the points/verbs.
+ */
+enum class SkPathIsAType : uint8_t {
+    kGeneral,
+    kOval,
+    kRRect,
+};
+
+struct SkPathIsAData {
+    uint8_t         fStartIndex;
+    SkPathDirection fDirection;
+};
 
 /**
  * Holds the path verbs and points. It is versioned by a generation ID. None of its public methods
@@ -49,18 +107,11 @@ public:
     // See https://bugs.chromium.org/p/skia/issues/detail?id=13817 for how these sizes were
     // determined.
     using PointsArray = skia_private::STArray<4, SkPoint>;
-    using VerbsArray = skia_private::STArray<4, uint8_t>;
-    using ConicWeightsArray = skia_private::STArray<2, SkScalar>;
-
-    enum class PathType : uint8_t {
-        kGeneral,
-        kOval,
-        kRRect,
-        kArc,
-    };
+    using VerbsArray = skia_private::STArray<4, SkPathVerb>;
+    using ConicWeightsArray = skia_private::STArray<2, float>;
 
-    SkPathRef(SkSpan<const SkPoint> points, SkSpan<const uint8_t> verbs,
-              SkSpan<const SkScalar> weights, unsigned segmentMask)
+    SkPathRef(SkSpan<const SkPoint> points, SkSpan<const SkPathVerb> verbs,
+              SkSpan<const SkScalar> weights, unsigned segmentMask, const SkMatrix* mx)
         : fPoints(points)
         , fVerbs(verbs)
         , fConicWeights(weights)
@@ -68,15 +119,11 @@ public:
         fBoundsIsDirty = true;    // this also invalidates fIsFinite
         fGenerationID = 0;        // recompute
         fSegmentMask = segmentMask;
-        fType = PathType::kGeneral;
-        // The next two values don't matter unless fType is kOval or kRRect
-        fRRectOrOvalIsCCW = false;
-        fRRectOrOvalStartIdx = 0xAC;
-        fArcOval.setEmpty();
-        fArcStartAngle = fArcSweepAngle = 0.0f;
-        fArcType = SkArc::Type::kArc;
+        fType = SkPathIsAType::kGeneral;
         SkDEBUGCODE(fEditorsAttached.store(0);)
-
+        if (mx && !mx->isIdentity()) {
+            mx->mapPoints(fPoints);
+        }
         this->computeBounds();  // do this now, before we worry about multiple owners/threads
         SkDEBUGCODE(this->validate();)
     }
@@ -107,7 +154,7 @@ public:
          * return value is a pointer to where the points for the verb should be written.
          * 'weight' is only used if 'verb' is kConic_Verb
          */
-        SkPoint* growForVerb(int /*SkPath::Verb*/ verb, SkScalar weight = 0) {
+        SkPoint* growForVerb(SkPathVerb verb, SkScalar weight = 0) {
             SkDEBUGCODE(fPathRef->validate();)
             return fPathRef->growForVerb(verb, weight);
         }
@@ -119,7 +166,7 @@ public:
          * If 'verb' is kConic_Verb, 'weights' will return a pointer to the
          * space for the conic weights (indexed normally).
          */
-        SkPoint* growForRepeatedVerb(int /*SkPath::Verb*/ verb,
+        SkPoint* growForRepeatedVerb(SkPathVerb verb,
                                      int numVbs,
                                      SkScalar** weights = nullptr) {
             return fPathRef->growForRepeatedVerb(verb, numVbs, weights);
@@ -149,16 +196,12 @@ public:
          */
         SkPathRef* pathRef() { return fPathRef; }
 
-        void setIsOval(bool isCCW, unsigned start) {
-            fPathRef->setIsOval(isCCW, start);
-        }
-
-        void setIsRRect(bool isCCW, unsigned start) {
-            fPathRef->setIsRRect(isCCW, start);
+        void setIsOval(SkPathDirection dir, unsigned start) {
+            fPathRef->setIsOval(dir, start);
         }
 
-        void setIsArc(const SkArc& arc) {
-            fPathRef->setIsArc(arc);
+        void setIsRRect(SkPathDirection dir, unsigned start) {
+            fPathRef->setIsRRect(dir, start);
         }
 
         void setBounds(const SkRect& rect) { fPathRef->setBounds(rect); }
@@ -167,34 +210,6 @@ public:
         SkPathRef* fPathRef;
     };
 
-    class SK_API Iter {
-    public:
-        Iter();
-        Iter(const SkPathRef&);
-
-        void setPathRef(const SkPathRef&);
-
-        /** Return the next verb in this iteration of the path. When all
-            segments have been visited, return kDone_Verb.
-
-            If any point in the path is non-finite, return kDone_Verb immediately.
-
-            @param  pts The points representing the current verb and/or segment
-                        This must not be NULL.
-            @return The verb for the current segment
-        */
-        uint8_t next(SkPoint pts[4]);
-        uint8_t peek() const;
-
-        SkScalar conicWeight() const { return *fConicWeights; }
-
-    private:
-        const SkPoint*  fPts;
-        const uint8_t*  fVerbs;
-        const uint8_t*  fVerbStop;
-        const SkScalar* fConicWeights;
-    };
-
 public:
     /**
      * Gets a path ref with no verbs or points.
@@ -219,46 +234,23 @@ public:
      */
     uint32_t getSegmentMasks() const { return fSegmentMask; }
 
-    /** Returns true if the path is an oval.
-     *
-     * @param rect      returns the bounding rect of this oval. It's a circle
-     *                  if the height and width are the same.
-     * @param isCCW     is the oval CCW (or CW if false).
-     * @param start     indicates where the contour starts on the oval (see
-     *                  SkPath::addOval for intepretation of the index).
-     *
-     * @return true if this path is an oval.
-     *              Tracking whether a path is an oval is considered an
-     *              optimization for performance and so some paths that are in
-     *              fact ovals can report false.
+    /** Returns Info struct if the path is an oval, else return {}.
+     *  Tracking whether a path is an oval is considered an
+     *  optimization for performance and so some paths that are in
+     *  fact ovals can report {}.
      */
-    bool isOval(SkRect* rect, bool* isCCW, unsigned* start) const {
-        if (fType == PathType::kOval) {
-            if (rect) {
-                *rect = this->getBounds();
-            }
-            if (isCCW) {
-                *isCCW = SkToBool(fRRectOrOvalIsCCW);
-            }
-            if (start) {
-                *start = fRRectOrOvalStartIdx;
-            }
+    std::optional<SkPathOvalInfo> isOval() const {
+        if (fType == SkPathIsAType::kOval) {
+            return {{
+                this->getBounds(),
+                fIsA.fDirection,
+                fIsA.fStartIndex,
+            }};
         }
-
-        return fType == PathType::kOval;
+        return {};
     }
 
-    bool isRRect(SkRRect* rrect, bool* isCCW, unsigned* start) const;
-
-    bool isArc(SkArc* arc) const {
-        if (fType == PathType::kArc) {
-            if (arc) {
-                *arc = SkArc::Make(fArcOval, fArcStartAngle, fArcSweepAngle, fArcType);
-            }
-        }
-
-        return fType == PathType::kArc;
-    }
+    std::optional<SkPathRRectInfo> isRRect() const;
 
     bool hasComputedBounds() const {
         return !fBoundsIsDirty;
@@ -304,16 +296,15 @@ public:
     /**
      * Returns a pointer one beyond the first logical verb (last verb in memory order).
      */
-    const uint8_t* verbsBegin() const { return fVerbs.begin(); }
+    const SkPathVerb* verbsBegin() const { return fVerbs.begin(); }
 
     /**
      * Returns a const pointer to the first verb in memory (which is the last logical verb).
      */
-    const uint8_t* verbsEnd() const { return fVerbs.end(); }
+    const SkPathVerb* verbsEnd() const { return fVerbs.end(); }
+
+    SkSpan<const SkPathVerb> verbs() const { return fVerbs; }
 
-    SkSpan<const SkPathVerb> verbs() const {
-        return {reinterpret_cast<const SkPathVerb*>(fVerbs.begin()), fVerbs.size()};
-    }
     /**
      * Returns a const pointer to the first point.
      */
@@ -324,14 +315,18 @@ public:
      */
     const SkPoint* pointsEnd() const { return this->points() + this->countPoints(); }
 
+    SkSpan<const SkPoint> pointSpan() const { return fPoints; }
+    SkSpan<const float> conicSpan() const { return fConicWeights; }
+
     const SkScalar* conicWeights() const { return fConicWeights.begin(); }
     const SkScalar* conicWeightsEnd() const { return fConicWeights.end(); }
 
+
     /**
      * Convenience methods for getting to a verb or point by index.
      */
-    uint8_t atVerb(int index) const { return fVerbs[index]; }
-    const SkPoint& atPoint(int index) const { return fPoints[index]; }
+    SkPathVerb atVerb(int index) const { return fVerbs[index]; }
+    SkPoint atPoint(int index) const { return fPoints[index]; }
 
     bool operator== (const SkPathRef& ref) const;
 
@@ -375,13 +370,8 @@ private:
         fBoundsIsDirty = true;    // this also invalidates fIsFinite
         fGenerationID = kEmptyGenID;
         fSegmentMask = 0;
-        fType = PathType::kGeneral;
-        // The next two values don't matter unless fType is kOval or kRRect
-        fRRectOrOvalIsCCW = false;
-        fRRectOrOvalStartIdx = 0xAC;
-        fArcOval.setEmpty();
-        fArcStartAngle = fArcSweepAngle = 0.0f;
-        fArcType = SkArc::Type::kArc;
+        fType = SkPathIsAType::kGeneral;
+
         if (numPoints > 0) {
             fPoints.reserve_exact(numPoints);
         }
@@ -448,7 +438,7 @@ private:
         fGenerationID = 0;
 
         fSegmentMask = 0;
-        fType = PathType::kGeneral;
+        fType = SkPathIsAType::kGeneral;
     }
 
     /** Resets the path ref with verbCount verbs and pointCount points, all uninitialized. Also
@@ -475,14 +465,14 @@ private:
      * verb. If 'verb' is kConic_Verb, 'weights' will return a pointer to the
      * uninitialized conic weights.
      */
-    SkPoint* growForRepeatedVerb(int /*SkPath::Verb*/ verb, int numVbs, SkScalar** weights);
+    SkPoint* growForRepeatedVerb(SkPathVerb, int numVbs, SkScalar** weights);
 
     /**
      * Increases the verb count 1, records the new verb, and creates room for the requisite number
      * of additional points. A pointer to the first point is returned. Any new points are
      * uninitialized.
      */
-    SkPoint* growForVerb(int /*SkPath::Verb*/ verb, SkScalar weight);
+    SkPoint* growForVerb(SkPathVerb, SkScalar weight);
 
     /**
      * Concatenates all verbs from 'path' onto our own verbs array. Increases the point count by the
@@ -495,37 +485,29 @@ private:
     /**
      * Private, non-const-ptr version of the public function verbsMemBegin().
      */
-    uint8_t* verbsBeginWritable() { return fVerbs.begin(); }
+    uint8_t* verbsBeginWritable() { return (uint8_t*)fVerbs.begin(); }
 
     /**
      * Called the first time someone calls CreateEmpty to actually create the singleton.
      */
     friend SkPathRef* sk_create_empty_pathref();
 
-    void setIsOval(bool isCCW, unsigned start) {
-        fType = PathType::kOval;
-        fRRectOrOvalIsCCW = isCCW;
-        fRRectOrOvalStartIdx = SkToU8(start);
-    }
-
-    void setIsRRect(bool isCCW, unsigned start) {
-        fType = PathType::kRRect;
-        fRRectOrOvalIsCCW = isCCW;
-        fRRectOrOvalStartIdx = SkToU8(start);
+    void setIsOval(SkPathDirection dir, unsigned start) {
+        fType = SkPathIsAType::kOval;
+        fIsA.fDirection  = dir;
+        fIsA.fStartIndex = SkToU8(start);
     }
 
-    void setIsArc(const SkArc& arc) {
-        fType = PathType::kArc;
-        fArcOval = arc.fOval;
-        fArcStartAngle = arc.fStartAngle;
-        fArcSweepAngle = arc.fSweepAngle;
-        fArcType = arc.fType;
+    void setIsRRect(SkPathDirection dir, unsigned start) {
+        fType = SkPathIsAType::kRRect;
+        fIsA.fDirection  = dir;
+        fIsA.fStartIndex = SkToU8(start);
     }
 
     // called only by the editor. Note that this is not a const function.
     SkPoint* getWritablePoints() {
         SkDEBUGCODE(this->validate();)
-        fType = PathType::kGeneral;
+        fType = SkPathIsAType::kGeneral;
         return fPoints.begin();
     }
 
@@ -541,7 +523,6 @@ private:
     ConicWeightsArray fConicWeights;
 
     mutable SkRect   fBounds;
-    SkRect           fArcOval;
 
     enum {
         kEmptyGenID = 1, // GenID reserved for path ref with zero points and zero verbs.
@@ -551,23 +532,13 @@ private:
 
     SkDEBUGCODE(std::atomic<int> fEditorsAttached;) // assert only one editor in use at any time.
 
-    SkScalar    fArcStartAngle;
-    SkScalar    fArcSweepAngle;
-
-    PathType fType;
-
-    mutable uint8_t  fBoundsIsDirty;
-
-    uint8_t  fRRectOrOvalStartIdx;
-    uint8_t  fSegmentMask;
-    // If the path is an arc, these four variables store that information.
-    // We should just store an SkArc, but alignment would cost us 8 more bytes.
-    SkArc::Type fArcType;
+    // based on fType
+    SkPathIsAData fIsA {};
 
-    mutable bool     fIsFinite;    // only meaningful if bounds are valid
-    // Both the circle and rrect special cases have a notion of direction and starting point
-    // The next two variables store that information for either.
-    bool     fRRectOrOvalIsCCW;
+    SkPathIsAType   fType;
+    uint8_t         fSegmentMask;
+    mutable bool    fBoundsIsDirty;
+    mutable bool    fIsFinite;    // only meaningful if bounds are valid
 
     friend class PathRefTest_Private;
     friend class ForceIsRRect_Private; // unit test isRRect

package/cpp/skia/include/private/base/SkTemplates.h

@@ -102,17 +102,17 @@ template <typename T> class AutoTArray  {
 public:
     AutoTArray() {}
     // Allocate size number of T elements
-    explicit AutoTArray(size_t size) {
-        fSize = check_size_bytes_too_big<T>(size);
-        fData.reset(size > 0 ? new T[size] : nullptr);
-    }
+    explicit AutoTArray(size_t size)
+        : fData(size > 0 ? new T[check_size_bytes_too_big<T>(size)] : nullptr)
+        , fSize(size) {}
 
     // TODO: remove when all uses are gone.
     explicit AutoTArray(int size) : AutoTArray(SkToSizeT(size)) {}
 
-    AutoTArray(AutoTArray&& other) : fData(std::move(other.fData)) {
-        fSize = std::exchange(other.fSize, 0);
-    }
+    AutoTArray(AutoTArray&& other)
+        : fData(std::move(other.fData))
+        , fSize(std::exchange(other.fSize, 0)) {}
+
     AutoTArray& operator=(AutoTArray&& other) {
         if (this != &other) {
             fData = std::move(other.fData);
@@ -122,6 +122,7 @@ public:
     }
 
     // Reallocates given a new count. Reallocation occurs even if new count equals old count.
+    [[clang::reinitializes]]
     void reset(size_t count = 0) {
         *this = AutoTArray(count);
     }
@@ -166,26 +167,38 @@ private:
     size_t fSize = 0;
 };
 
-/** Like AutoTArray with room for kCountRequested elements preallocated on
- *  the Stack. If count exceeds the space of the preallocation, the elements
- *  will live on the heap. Once this goes out of scope, the elements will be
- *  cleaned up "auto"matically.
+/** Like AutoTArray with storage for some number of elements "nested within". The requested number
+ *  of elements to fit in the storage is specified by kCountRequested. kCount is the actual number
+ *  of elements that will fit in the storage. If the runtime number of elements exceeds the space of
+ *  the storage, the elements will live on the heap.
  */
 template <int kCountRequested, typename T> class AutoSTArray {
 public:
-    AutoSTArray(AutoSTArray&&) = delete;
     AutoSTArray(const AutoSTArray&) = delete;
-    AutoSTArray& operator=(AutoSTArray&&) = delete;
     AutoSTArray& operator=(const AutoSTArray&) = delete;
 
+    AutoSTArray(AutoSTArray&& that) {
+        if (that.fArray == nullptr) {
+            fArray = nullptr;
+            fCount = 0;
+        } else if (that.fArray == (T*) that.fStorage) {
+            fArray = (T*) fStorage;
+            fCount = that.fCount;
+            std::uninitialized_move(that.fArray, that.fArray + that.fCount, fArray);
+        } else {
+            fArray = std::exchange(that.fArray, nullptr);
+            fCount = std::exchange(that.fCount, 0);
+        }
+    }
+    AutoSTArray& operator=(AutoSTArray&&) = delete;
+
     /** Initialize with no objects */
     AutoSTArray() {
         fArray = nullptr;
         fCount = 0;
     }
 
-    /** Allocate count number of T elements
-     */
+    /** Allocate count number of T elements */
     AutoSTArray(int count) {
         fArray = nullptr;
         fCount = 0;
@@ -197,18 +210,17 @@ public:
     }
 
     /** Destroys previous objects in the array and default constructs count number of objects */
+    [[clang::reinitializes]]
     void reset(int count) {
-        T* start = fArray;
-        T* iter = start + fCount;
+        T* start = begin();
+        T* iter = end();
         while (iter > start) {
             (--iter)->~T();
         }
 
         SkASSERT(count >= 0);
         if (fCount != count) {
-            if (fCount > kCount) {
-                // 'fArray' was allocated last time so free it now
-                SkASSERT((T*) fStorage != fArray);
+            if (fArray != (T*) fStorage) {
                 sk_free(fArray);
             }
 
@@ -223,19 +235,31 @@ public:
             fCount = count;
         }
 
-        iter = fArray;
-        T* stop = fArray + count;
+        iter = begin();
+        T* stop = end();
         while (iter < stop) {
             new (iter++) T;
         }
     }
 
-    /** Return the number of T elements in the array
-     */
+    /* Removes elements with index >= count */
+    void trimTo(int count) {
+        SkASSERT(count >= 0);
+        if (count >= fCount) {
+            return;
+        }
+        T* start = begin() + count;
+        T* iter = end();
+        while (iter > start) {
+            (--iter)->~T();
+        }
+        fCount = count;
+    }
+
+    /** Return the number of T elements in the array */
     int count() const { return fCount; }
 
-    /** Return the array of T elements. Will be NULL if count == 0
-     */
+    /** Return the array of T elements. Will be nullptr if count == 0 */
     T* get() const { return fArray; }
 
     T* begin() { return fArray; }
@@ -246,8 +270,7 @@ public:
 
     const T* end() const { return fArray + fCount; }
 
-    /** Return the nth element in the array
-     */
+    /** Return the nth element in the array */
     T&  operator[](int index) const {
         return fArray[sk_collection_check_bounds(index, fCount)];
     }
@@ -274,9 +297,11 @@ private:
     // Thus, we can expand how many elements are stored on the stack to make use of this
     // (e.g. 1 extra element for 4 byte T if kCountRequested was even).
     static_assert(alignof(int) <= alignof(T*) || alignof(int) <= alignof(T));
+public:
     static constexpr int kCount =
             SkAlignTo(kMinCount*sizeof(T) + sizeof(int), std::max(alignof(T*), alignof(T))) / sizeof(T);
 
+private:
     T* fArray;
     alignas(T) std::byte fStorage[kCount * sizeof(T)];
     int fCount;
@@ -306,6 +331,7 @@ public:
     }
 
     /** Resize the memory area pointed to by the current ptr without preserving contents. */
+    [[clang::reinitializes]]
     T* reset(size_t count = 0) {
         fPtr.reset(count ? (T*)sk_malloc_throw(count, sizeof(T)) : nullptr);
         return this->get();
@@ -354,11 +380,21 @@ public:
         }
     }
 
-    AutoSTMalloc(AutoSTMalloc&&) = delete;
     AutoSTMalloc(const AutoSTMalloc&) = delete;
-    AutoSTMalloc& operator=(AutoSTMalloc&&) = delete;
     AutoSTMalloc& operator=(const AutoSTMalloc&) = delete;
 
+    AutoSTMalloc(AutoSTMalloc&& that) {
+        if (that.fPtr == nullptr) {
+            fPtr = nullptr;
+        } else if (that.fPtr == that.fTStorage) {
+            fPtr = fTStorage;
+            memcpy(fPtr, that.fPtr, kCount * sizeof(T));
+        } else {
+            fPtr = std::exchange(that.fPtr, nullptr);
+        }
+    }
+    AutoSTMalloc& operator=(AutoSTMalloc&&) = delete;
+
     ~AutoSTMalloc() {
         if (fPtr != fTStorage) {
             sk_free(fPtr);
@@ -366,6 +402,7 @@ public:
     }
 
     // doesn't preserve contents
+    [[clang::reinitializes]]
     T* reset(size_t count) {
         if (fPtr != fTStorage) {
             sk_free(fPtr);
@@ -427,13 +464,18 @@ private:
     // Stack frame size is limited for SK_BUILD_FOR_GOOGLE3. 4k is less than the actual max, but some functions
     // have multiple large stack allocations.
     static constexpr size_t kMaxBytes = 4 * 1024;
-    static constexpr size_t kCount = kCountRequested * sizeof(T) > kMaxBytes
+    static constexpr size_t kMinCount = kCountRequested * sizeof(T) > kMaxBytes
         ? kMaxBytes / sizeof(T)
         : kCountWithPadding;
 #else
-    static constexpr size_t kCount = kCountWithPadding;
+    static constexpr size_t kMinCount = kCountWithPadding;
 #endif
 
+public:
+    static constexpr size_t kCount = kMinCount;
+
+private:
+
     T*          fPtr;
     union {
         uint32_t    fStorage32[SkAlign4(kCount*sizeof(T)) >> 2];

package/cpp/skia/include/utils/SkParsePath.h

@@ -16,7 +16,15 @@ class SkString;
 
 class SK_API SkParsePath {
 public:
-    static bool FromSVGString(const char str[], SkPath*);
+    static std::optional<SkPath> FromSVGString(const char str[]);
+    // Deprecated
+    static bool FromSVGString(const char str[], SkPath* outPath) {
+        if (auto result = FromSVGString(str)) {
+            *outPath = *result;
+            return true;
+        }
+        return false;
+    }
 
     enum class PathEncoding { Absolute, Relative };
     static SkString ToSVGString(const SkPath&, PathEncoding = PathEncoding::Absolute);