@shopify/react-native-skia 2.6.0 → 2.6.2

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

@@ -9,12 +9,14 @@
 #define SkHdrMetadata_DEFINED
 
 #include "include/core/SkColorSpace.h"
-#include "include/core/SkRefCnt.h"
+#include "include/core/SkData.h"
 #include "include/private/base/SkAPI.h"
 
+#include <memory>
 #include <optional>
+#include <vector>
 
-
+class SkColorFilter;
 class SkData;
 class SkString;
 
@@ -121,6 +123,131 @@ struct SK_API MasteringDisplayColorVolume {
     }
 };
 
+/**
+ * Adaptive Global Tone Map
+ * This structure contains the metadata items from the ColorVolumeTransform metadata group
+ * in Clause 7.1: Metadata set of SMPTE ST 2094-50: Dynamic metadata for color volume transform
+ * Application #5
+ * https://github.com/SMPTE/st2094-50
+ * WARNING: This specification is still a DRAFT and is subject to change before publication.
+ */
+struct SK_API AdaptiveGlobalToneMap {
+    // A GainCurve metadata group.
+    struct SK_API GainCurve {
+        // Structure holding one entry of the GainCurveControlPointX, GainCurveControlPointY, and
+        // GainCurveControlPointM metadata items.
+        struct ControlPoint {
+            float fX = 0.f;
+            float fY = 0.f;
+            float fM = 0.f;
+
+            bool operator==(const ControlPoint& other) const {
+                return fX == other.fX && fY == other.fY && fM == other.fM;
+            }
+        };
+
+        // The size of this vector is the value of the GainCurveNumControlPoints metadata item.
+        static constexpr size_t kMinNumControlPoints = 1u;
+        static constexpr size_t kMaxNumControlPoints = 32u;
+        std::vector<ControlPoint> fControlPoints = {};
+
+        bool operator==(const GainCurve& other) const {
+            return fControlPoints == other.fControlPoints;
+        }
+    };
+
+    // A ComponentMix metadata group.
+    struct SK_API ComponentMixingFunction {
+        // The ComponentMixRed/Green/Blue/Max/Min/Component metadata items.
+        float fRed = 0.f;
+        float fGreen = 0.f;
+        float fBlue = 0.f;
+        float fMax = 0.f;
+        float fMin = 0.f;
+        float fComponent = 0.f;
+
+        bool operator==(const ComponentMixingFunction& other) const {
+            return fRed == other.fRed && fGreen == other.fGreen && fBlue == other.fBlue &&
+                   fMax == other.fMax && fMin == other.fMin && fComponent == other.fComponent;
+        }
+    };
+
+    // A ColorGainFunction metadata group.
+    struct SK_API ColorGainFunction {
+        // The ComponentMix metadata group.
+        ComponentMixingFunction fComponentMixing = {};
+
+        // The GainCurve metadata group.
+        GainCurve fGainCurve = {};
+
+        bool operator==(const ColorGainFunction& other) const {
+            return fComponentMixing == other.fComponentMixing && fGainCurve == other.fGainCurve;
+        }
+    };
+
+    // Structure holding the metadata items and groups for an alternate image.
+    struct SK_API AlternateImage {
+        // The AlternateHdrHeadroom metadata item.
+        float fHdrHeadroom = 0.f;
+
+        // The ColorGainFunction metadata group.
+        ColorGainFunction fColorGainFunction = {};
+
+        bool operator==(const AlternateImage& other) const {
+            return fHdrHeadroom == other.fHdrHeadroom && fColorGainFunction == other.fColorGainFunction;
+        }
+    };
+
+    // HeadroomAdaptiveToneMap metadata group.
+    struct SK_API HeadroomAdaptiveToneMap {
+        // The BaselineHdrHeadroom metadata item.
+        float fBaselineHdrHeadroom = 0.f;
+
+        // The GainApplicationSpaceColorPrimaries metadata item.
+        SkColorSpacePrimaries fGainApplicationSpacePrimaries =
+            {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
+
+        // The size of this vector is the NumAlternateImages metadata item.
+        static constexpr size_t kMaxNumAlternateImages = 4u;
+        std::vector<AlternateImage> fAlternateImages = {};
+
+        bool operator==(const HeadroomAdaptiveToneMap& other) const {
+            return fBaselineHdrHeadroom == other.fBaselineHdrHeadroom &&
+                   fGainApplicationSpacePrimaries == other.fGainApplicationSpacePrimaries &&
+                   fAlternateImages == other.fAlternateImages;
+        }
+    };
+
+    // The default value for the HdrReferenceWhite metadata item.
+    static constexpr float kDefaultHdrReferenceWhite = 203.f;
+
+    // The HdrReferenceWhite metadata item.
+    float fHdrReferenceWhite = kDefaultHdrReferenceWhite;
+
+    // The HeadroomAdaptiveToneMap metadata group.
+    std::optional<HeadroomAdaptiveToneMap> fHeadroomAdaptiveToneMap = std::nullopt;
+
+    /**
+     * Decode from the binary encoding in Annex C.
+     */
+    bool parse(const SkData* data);
+
+    /**
+     * Serialize to the encoding used by parse().
+     */
+    sk_sp<SkData> serialize() const;
+
+    /**
+     * Return a human-readable description.
+     */
+    SkString toString() const;
+
+    bool operator==(const AdaptiveGlobalToneMap& other) const {
+        return fHdrReferenceWhite == other.fHdrReferenceWhite &&
+               fHeadroomAdaptiveToneMap == other.fHeadroomAdaptiveToneMap;
+    }
+};
+
 /**
  * Structure containing all HDR metadata that can be attached to an image or video frame.
  */
@@ -153,11 +280,46 @@ class SK_API Metadata {
      */
     void setMasteringDisplayColorVolume(const MasteringDisplayColorVolume& mdcv);
 
+    /**
+     * If there does not exists Adaptive Global Tone Map metadata, then return false.
+     * Otherwise return true and if `agtm` is non-nullptr then write the metadata to `agtm`.
+     */
+    bool getAdaptiveGlobalToneMap(AdaptiveGlobalToneMap* agtm) const;
+
+    /**
+     * Set the Adaptive Global Tone Map metadata.
+     */
+    void setAdaptiveGlobalToneMap(const AdaptiveGlobalToneMap& agtm);
+
+    /**
+     * Return the serialized Adaptive Global Tone Mapping metadata, or nullptr if none has been set.
+     */
+    sk_sp<const SkData> getSerializedAgtm() const;
+
+    /**
+     * Set the serialized Adaptive Global Tone Mapping metadata.
+     */
+    void setSerializedAgtm(sk_sp<const SkData>);
+
     /**
      * Return a human-readable description.
      */
     SkString toString() const;
 
+    /**
+     * Return the SkColorFilter to tone map to the specified targeted HDR headroom.
+     *
+     * The `inputColorSpace` parameter is the color space of the input image that will be
+     * used with the image. If it is PQ or HLG, then the color filter will effectively
+     * reinterpret the image as having the HDR reference white parameter indicated in the
+     * metadata.
+     *
+     * If `inputColorSpace` is PQ or HLG, then a default tone mapping will be provided,
+     * inferring the baseline HDR headroom from the CLLI or MDCV metadata, if present.
+     */
+    sk_sp<SkColorFilter> makeToneMapColorFilter(
+        float targetedHdrHeadroom, const SkColorSpace* inputColorSpace = nullptr) const;
+
     bool operator==(const Metadata& other) const;
     bool operator!=(const Metadata& other) const {
       return !(*this == other);
@@ -166,6 +328,7 @@ class SK_API Metadata {
   private:
     std::optional<ContentLightLevelInformation> fContentLightLevelInformation;
     std::optional<MasteringDisplayColorVolume> fMasteringDisplayColorVolume;
+    std::optional<AdaptiveGlobalToneMap> fAdaptiveGlobalToneMap;
 };
 
 }  // namespace skhdr

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

@@ -87,461 +87,4 @@ struct SkPathIsAData {
     SkPathDirection fDirection;
 };
 
-/**
- * Holds the path verbs and points. It is versioned by a generation ID. None of its public methods
- * modify the contents. To modify or append to the verbs/points wrap the SkPathRef in an
- * SkPathRef::Editor object. Installing the editor resets the generation ID. It also performs
- * copy-on-write if the SkPathRef is shared by multiple SkPaths. The caller passes the Editor's
- * constructor a pointer to a sk_sp<SkPathRef>, which may be updated to point to a new SkPathRef
- * after the editor's constructor returns.
- *
- * The points and verbs are stored in a single allocation. The points are at the begining of the
- * allocation while the verbs are stored at end of the allocation, in reverse order. Thus the points
- * and verbs both grow into the middle of the allocation until the meet. To access verb i in the
- * verb array use ref.verbs()[~i] (because verbs() returns a pointer just beyond the first
- * logical verb or the last verb in memory).
- */
-
-class SK_API SkPathRef final : public SkNVRefCnt<SkPathRef> {
-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, SkPathVerb>;
-    using ConicWeightsArray = skia_private::STArray<2, float>;
-
-    SkPathRef(SkSpan<const SkPoint> points, SkSpan<const SkPathVerb> verbs,
-              SkSpan<const SkScalar> weights, unsigned segmentMask, const SkMatrix* mx)
-        : fPoints(points)
-        , fVerbs(verbs)
-        , fConicWeights(weights)
-    {
-        fBoundsIsDirty = true;    // this also invalidates fIsFinite
-        fGenerationID = 0;        // recompute
-        fSegmentMask = SkToU8(segmentMask);
-        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();)
-    }
-
-    class Editor {
-    public:
-        Editor(sk_sp<SkPathRef>* pathRef,
-               int incReserveVerbs = 0,
-               int incReservePoints = 0,
-               int incReserveConics = 0);
-
-        ~Editor() { SkDEBUGCODE(fPathRef->fEditorsAttached--;) }
-
-        /**
-         * Returns the array of points.
-         */
-        SkPoint* writablePoints() { return fPathRef->getWritablePoints(); }
-        const SkPoint* points() const { return fPathRef->points(); }
-
-        /**
-         * Gets the ith point. Shortcut for this->points() + i
-         */
-        SkPoint* atPoint(int i) { return fPathRef->getWritablePoints() + i; }
-        const SkPoint* atPoint(int i) const { return &fPathRef->fPoints[i]; }
-
-        /**
-         * Adds the verb and allocates space for the number of points indicated by the verb. The
-         * 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(SkPathVerb verb, SkScalar weight = 0) {
-            SkDEBUGCODE(fPathRef->validate();)
-            return fPathRef->growForVerb(verb, weight);
-        }
-
-        /**
-         * Allocates space for multiple instances of a particular verb and the
-         * requisite points & weights.
-         * The return pointer points at the first new point (indexed normally [<i>]).
-         * If 'verb' is kConic_Verb, 'weights' will return a pointer to the
-         * space for the conic weights (indexed normally).
-         */
-        SkPoint* growForRepeatedVerb(SkPathVerb verb,
-                                     int numVbs,
-                                     SkScalar** weights = nullptr) {
-            return fPathRef->growForRepeatedVerb(verb, numVbs, weights);
-        }
-
-        /**
-         * Concatenates all verbs from 'path' onto the pathRef's verbs array. Increases the point
-         * count by the number of points in 'path', and the conic weight count by the number of
-         * conics in 'path'.
-         *
-         * Returns pointers to the uninitialized points and conic weights data.
-         */
-        std::tuple<SkPoint*, SkScalar*> growForVerbsInPath(const SkPathRef& path) {
-            return fPathRef->growForVerbsInPath(path);
-        }
-
-        /**
-         * Resets the path ref to a new verb and point count. The new verbs and points are
-         * uninitialized.
-         */
-        void resetToSize(int newVerbCnt, int newPointCnt, int newConicCount) {
-            fPathRef->resetToSize(newVerbCnt, newPointCnt, newConicCount);
-        }
-
-        /**
-         * Gets the path ref that is wrapped in the Editor.
-         */
-        SkPathRef* pathRef() { return fPathRef; }
-
-        void setIsOval(SkPathDirection dir, unsigned start) {
-            fPathRef->setIsOval(dir, start);
-        }
-
-        void setIsRRect(SkPathDirection dir, unsigned start) {
-            fPathRef->setIsRRect(dir, start);
-        }
-
-        void setBounds(const SkRect& rect) { fPathRef->setBounds(rect); }
-
-    private:
-        SkPathRef* fPathRef;
-    };
-
-public:
-    /**
-     * Gets a path ref with no verbs or points.
-     */
-    static SkPathRef* CreateEmpty();
-
-    /**
-     *  Returns true if all of the points in this path are finite, meaning there
-     *  are no infinities and no NaNs.
-     */
-    bool isFinite() const {
-        if (fBoundsIsDirty) {
-            this->computeBounds();
-        }
-        return SkToBool(fIsFinite);
-    }
-
-    /**
-     *  Returns a mask, where each bit corresponding to a SegmentMask is
-     *  set if the path contains 1 or more segments of that type.
-     *  Returns 0 for an empty path (no segments).
-     */
-    uint32_t getSegmentMasks() const { return fSegmentMask; }
-
-    /** 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 {}.
-     */
-    std::optional<SkPathOvalInfo> isOval() const {
-        if (fType == SkPathIsAType::kOval) {
-            return {{
-                this->getBounds(),
-                fIsA.fDirection,
-                fIsA.fStartIndex,
-            }};
-        }
-        return {};
-    }
-
-    std::optional<SkPathRRectInfo> isRRect() const;
-
-    bool hasComputedBounds() const {
-        return !fBoundsIsDirty;
-    }
-
-    /** Returns the bounds of the path's points. If the path contains 0 or 1
-        points, the bounds is set to (0,0,0,0), and isEmpty() will return true.
-        Note: this bounds may be larger than the actual shape, since curves
-        do not extend as far as their control points.
-    */
-    const SkRect& getBounds() const {
-        if (fBoundsIsDirty) {
-            this->computeBounds();
-        }
-        return fBounds;
-    }
-
-    SkRRect getRRect() const;
-
-    /**
-     * Transforms a path ref by a matrix, allocating a new one only if necessary.
-     */
-    static void CreateTransformedCopy(sk_sp<SkPathRef>* dst,
-                                      const SkPathRef& src,
-                                      const SkMatrix& matrix);
-
-  //  static SkPathRef* CreateFromBuffer(SkRBuffer* buffer);
-
-    /**
-     * Rollsback a path ref to zero verbs and points with the assumption that the path ref will be
-     * repopulated with approximately the same number of verbs and points. A new path ref is created
-     * only if necessary.
-     */
-    static void Rewind(sk_sp<SkPathRef>* pathRef);
-
-    ~SkPathRef();
-    int countPoints() const { return fPoints.size(); }
-    int countVerbs() const { return fVerbs.size(); }
-    int countWeights() const { return fConicWeights.size(); }
-
-    size_t approximateBytesUsed() const;
-
-    /**
-     * Returns a pointer one beyond the first logical verb (last verb in memory order).
-     */
-    const SkPathVerb* verbsBegin() const { return fVerbs.begin(); }
-
-    /**
-     * Returns a const pointer to the first verb in memory (which is the last logical verb).
-     */
-    const SkPathVerb* verbsEnd() const { return fVerbs.end(); }
-
-    SkSpan<const SkPathVerb> verbs() const { return fVerbs; }
-
-    /**
-     * Returns a const pointer to the first point.
-     */
-    const SkPoint* points() const { return fPoints.begin(); }
-
-    /**
-     * Shortcut for this->points() + this->countPoints()
-     */
-    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.
-     */
-    SkPathVerb atVerb(int index) const { return fVerbs[index]; }
-    SkPoint atPoint(int index) const { return fPoints[index]; }
-
-    bool operator== (const SkPathRef& ref) const;
-
-    /**
-     * Gets an ID that uniquely identifies the contents of the path ref. If two path refs have the
-     * same ID then they have the same verbs and points. However, two path refs may have the same
-     * contents but different genIDs.
-     * skbug.com/40032862 for background on why fillType is necessary (for now).
-     */
-    uint32_t genID(SkPathFillType fillType) const;
-
-    void addGenIDChangeListener(sk_sp<SkIDChangeListener>);   // Threadsafe.
-    int genIDChangeListenerCount();                           // Threadsafe
-
-    bool dataMatchesVerbs() const;
-    bool isValid() const;
-    SkDEBUGCODE(void validate() const { SkASSERT(this->isValid()); } )
-
-    /**
-     * Resets this SkPathRef to a clean state.
-     */
-    void reset();
-
-    bool isInitialEmptyPathRef() const {
-        return fGenerationID == kEmptyGenID;
-    }
-
-private:
-    enum SerializationOffsets {
-        kLegacyRRectOrOvalStartIdx_SerializationShift = 28, // requires 3 bits, ignored.
-        kLegacyRRectOrOvalIsCCW_SerializationShift = 27,    // requires 1 bit, ignored.
-        kLegacyIsRRect_SerializationShift = 26,             // requires 1 bit, ignored.
-        kIsFinite_SerializationShift = 25,                  // requires 1 bit
-        kLegacyIsOval_SerializationShift = 24,              // requires 1 bit, ignored.
-        kSegmentMask_SerializationShift = 0                 // requires 4 bits (deprecated)
-    };
-
-    SkPathRef(int numVerbs = 0, int numPoints = 0, int numConics = 0) {
-        fBoundsIsDirty = true;    // this also invalidates fIsFinite
-        fGenerationID = kEmptyGenID;
-        fSegmentMask = 0;
-        fType = SkPathIsAType::kGeneral;
-
-        if (numPoints > 0) {
-            fPoints.reserve_exact(numPoints);
-        }
-        if (numVerbs > 0) {
-            fVerbs.reserve_exact(numVerbs);
-        }
-        if (numConics > 0) {
-            fConicWeights.reserve_exact(numConics);
-        }
-        SkDEBUGCODE(fEditorsAttached.store(0);)
-        SkDEBUGCODE(this->validate();)
-    }
-
-    void copy(const SkPathRef& ref, int additionalReserveVerbs, int additionalReservePoints, int additionalReserveConics);
-
-    // Return true if the computed bounds are finite.
-    static bool ComputePtBounds(SkRect* bounds, const SkPathRef& ref) {
-        return bounds->setBoundsCheck(ref.pointSpan());
-    }
-
-    // called, if dirty, by getBounds()
-    void computeBounds() const {
-        SkDEBUGCODE(this->validate();)
-        // TODO: remove fBoundsIsDirty and fIsFinite,
-        // using an inverted rect instead of fBoundsIsDirty and always recalculating fIsFinite.
-        SkASSERT(fBoundsIsDirty);
-
-        fIsFinite = ComputePtBounds(&fBounds, *this);
-        fBoundsIsDirty = false;
-    }
-
-    void setBounds(const SkRect& rect) {
-        SkASSERT(rect.fLeft <= rect.fRight && rect.fTop <= rect.fBottom);
-        fBounds = rect;
-        fBoundsIsDirty = false;
-        fIsFinite = fBounds.isFinite();
-    }
-
-    /** Makes additional room but does not change the counts or change the genID */
-    void incReserve(int additionalVerbs, int additionalPoints, int additionalConics) {
-        SkDEBUGCODE(this->validate();)
-        // Use reserve() so that if there is not enough space, the array will grow with some
-        // additional space. This ensures repeated calls to grow won't always allocate.
-        if (additionalPoints > 0) {
-            fPoints.reserve(fPoints.size() + additionalPoints);
-        }
-        if (additionalVerbs > 0) {
-            fVerbs.reserve(fVerbs.size() + additionalVerbs);
-        }
-        if (additionalConics > 0) {
-            fConicWeights.reserve(fConicWeights.size() + additionalConics);
-        }
-        SkDEBUGCODE(this->validate();)
-    }
-
-    /**
-     * Resets all state except that of the verbs, points, and conic-weights.
-     * Intended to be called from other functions that reset state.
-     */
-    void commonReset() {
-        SkDEBUGCODE(this->validate();)
-        this->callGenIDChangeListeners();
-        fBoundsIsDirty = true;      // this also invalidates fIsFinite
-        fGenerationID = 0;
-
-        fSegmentMask = 0;
-        fType = SkPathIsAType::kGeneral;
-    }
-
-    /** Resets the path ref with verbCount verbs and pointCount points, all uninitialized. Also
-     *  allocates space for reserveVerb additional verbs and reservePoints additional points.*/
-    void resetToSize(int verbCount, int pointCount, int conicCount,
-                     int reserveVerbs = 0, int reservePoints = 0,
-                     int reserveConics = 0) {
-        this->commonReset();
-        // Use reserve_exact() so the arrays are sized to exactly fit the data.
-        fPoints.reserve_exact(pointCount + reservePoints);
-        fPoints.resize_back(pointCount);
-
-        fVerbs.reserve_exact(verbCount + reserveVerbs);
-        fVerbs.resize_back(verbCount);
-
-        fConicWeights.reserve_exact(conicCount + reserveConics);
-        fConicWeights.resize_back(conicCount);
-        SkDEBUGCODE(this->validate();)
-    }
-
-    /**
-     * Increases the verb count by numVbs and point count by the required amount.
-     * The new points are uninitialized. All the new verbs are set to the specified
-     * verb. If 'verb' is kConic_Verb, 'weights' will return a pointer to the
-     * uninitialized conic 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(SkPathVerb, SkScalar weight);
-
-    /**
-     * Concatenates all verbs from 'path' onto our own verbs array. Increases the point count by the
-     * number of points in 'path', and the conic weight count by the number of conics in 'path'.
-     *
-     * Returns pointers to the uninitialized points and conic weights data.
-     */
-    std::tuple<SkPoint*, SkScalar*> growForVerbsInPath(const SkPathRef& path);
-
-    /**
-     * Private, non-const-ptr version of the public function verbsMemBegin().
-     */
-    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(SkPathDirection dir, unsigned start) {
-        fType = SkPathIsAType::kOval;
-        fIsA.fDirection  = dir;
-        fIsA.fStartIndex = SkToU8(start);
-    }
-
-    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 = SkPathIsAType::kGeneral;
-        return fPoints.begin();
-    }
-
-    const SkPoint* getPoints() const {
-        SkDEBUGCODE(this->validate();)
-        return fPoints.begin();
-    }
-
-    void callGenIDChangeListeners();
-
-    PointsArray fPoints;
-    VerbsArray fVerbs;
-    ConicWeightsArray fConicWeights;
-
-    mutable SkRect   fBounds;
-
-    enum {
-        kEmptyGenID = 1, // GenID reserved for path ref with zero points and zero verbs.
-    };
-    mutable uint32_t    fGenerationID;
-    SkIDChangeListener::List fGenIDChangeListeners;
-
-    SkDEBUGCODE(std::atomic<int> fEditorsAttached;) // assert only one editor in use at any time.
-
-    // based on fType
-    SkPathIsAData fIsA {};
-
-    SkPathIsAType   fType;
-    uint8_t         fSegmentMask;
-    mutable bool    fBoundsIsDirty;
-    mutable bool    fIsFinite;    // only meaningful if bounds are valid
-
-    friend class PathRefTest_Private;
-    friend class SkPath;
-    friend class SkPathBuilder;
-    friend class SkPathPriv;
-};
-
 #endif

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

@@ -19,6 +19,10 @@
         #define SK_BUILD_FOR_WIN
     #elif defined(ANDROID) || defined(__ANDROID__)
         #define SK_BUILD_FOR_ANDROID
+    #elif defined(__EMSCRIPTEN__)
+        // WASM toolchains expose a Unix-like compilation environment, but it is
+        // not Unix (e.g. posix signals are not supported).
+        #define SK_BUILD_FOR_WASM
     #elif defined(linux) || defined(__linux) || defined(__FreeBSD__) || \
           defined(__OpenBSD__) || defined(__sun) || defined(__NetBSD__) || \
           defined(__DragonFly__) || defined(__Fuchsia__) || \

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

@@ -148,8 +148,7 @@ static constexpr float sk_float_midpoint(float a, float b) {
     return static_cast<float>(0.5 * (static_cast<double>(a) + b));
 }
 
-static inline float sk_float_rsqrt_portable(float x) { return 1.0f / std::sqrt(x); }
-static inline float sk_float_rsqrt         (float x) { return 1.0f / std::sqrt(x); }
+static inline float sk_float_rsqrt (float x) { return 1.0f / std::sqrt(x); }
 
 // IEEE defines how float divide behaves for non-finite values and zero-denoms, but C does not,
 // so we have a helper that suppresses the possible undefined-behavior warnings.