@shopify/react-native-skia 1.3.12 → 1.4.0

package/cpp/skia/include/gpu/vk/VulkanTypes.h

@@ -12,6 +12,7 @@
 #include "include/private/gpu/vk/SkiaVulkan.h"
 
 #include <cstddef>
+#include <cstdint>
 #include <functional>
 #include <string>
 #include <vector>
@@ -65,14 +66,24 @@ struct VulkanYcbcrConversionInfo {
         if (!this->isValid() && !that.isValid()) {
             return true;
         }
-        return this->fFormat == that.fFormat &&
-               this->fExternalFormat == that.fExternalFormat &&
-               this->fYcbcrModel == that.fYcbcrModel &&
-               this->fYcbcrRange == that.fYcbcrRange &&
-               this->fXChromaOffset == that.fXChromaOffset &&
-               this->fYChromaOffset == that.fYChromaOffset &&
-               this->fChromaFilter == that.fChromaFilter &&
-               this->fForceExplicitReconstruction == that.fForceExplicitReconstruction;
+
+        // Note that we do not need to check for fFormatFeatures equality. This is because the
+        // Vulkan spec dictates that Android hardware buffers with the same external format must
+        // have the same support for key features. See
+        // https://docs.vulkan.org/spec/latest/chapters/memory.html#_android_hardware_buffer_external_memory
+        // for more details.
+        return this->fFormat                      == that.fFormat                      &&
+               this->fExternalFormat              == that.fExternalFormat              &&
+               this->fYcbcrModel                  == that.fYcbcrModel                  &&
+               this->fYcbcrRange                  == that.fYcbcrRange                  &&
+               this->fXChromaOffset               == that.fXChromaOffset               &&
+               this->fYChromaOffset               == that.fYChromaOffset               &&
+               this->fChromaFilter                == that.fChromaFilter                &&
+               this->fForceExplicitReconstruction == that.fForceExplicitReconstruction &&
+               this->fComponents.r                == that.fComponents.r                &&
+               this->fComponents.g                == that.fComponents.g                &&
+               this->fComponents.b                == that.fComponents.b                &&
+               this->fComponents.a                == that.fComponents.a;
     }
     bool operator!=(const VulkanYcbcrConversionInfo& that) const { return !(*this == that); }
 
@@ -99,6 +110,12 @@ struct VulkanYcbcrConversionInfo {
     // For external images format features here should be those returned by a call to
     // vkAndroidHardwareBufferFormatPropertiesANDROID
     VkFormatFeatureFlags fFormatFeatures = 0;
+
+    // This is ignored when fExternalFormat is non-zero.
+    VkComponentMapping fComponents            = {VK_COMPONENT_SWIZZLE_IDENTITY,
+                                                 VK_COMPONENT_SWIZZLE_IDENTITY,
+                                                 VK_COMPONENT_SWIZZLE_IDENTITY,
+                                                 VK_COMPONENT_SWIZZLE_IDENTITY};
 };
 
 typedef void* VulkanDeviceLostContext;

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

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2024 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkFontMgr_fontations_DEFINED
+#define SkFontMgr_fontations_DEFINED
+
+#include "include/core/SkRefCnt.h"
+
+class SkFontMgr;
+
+/** Create a font manager instantiating fonts using the Rust Fontations backend.
+ * This font manager does not support matching fonts, only instantiation.
+ */
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_Fontations_Empty();
+
+#endif // #ifndef SkFontMgr_fontations_DEFINED

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

@@ -10,7 +10,10 @@
 
 #include "include/core/SkRefCnt.h"
 
+#include <memory>
+
 class SkFontMgr;
+class SkFontScanner;
 
 struct SkFontMgr_Android_CustomFonts {
     /** When specifying custom fonts, indicates how to use system fonts. */
@@ -40,6 +43,10 @@ struct SkFontMgr_Android_CustomFonts {
 };
 
 /** Create a font manager for Android. If 'custom' is NULL, use only system fonts. */
+
+// Deprecated
 SK_API sk_sp<SkFontMgr> SkFontMgr_New_Android(const SkFontMgr_Android_CustomFonts* custom);
 
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_Android(const SkFontMgr_Android_CustomFonts* custom,
+                                              std::unique_ptr<SkFontScanner> scanner);
 #endif // SkFontMgr_android_DEFINED

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

@@ -7,7 +7,9 @@
 #ifndef SkImageGeneratorCG_DEFINED
 #define SkImageGeneratorCG_DEFINED
 
-#include "include/private/base/SkFeatures.h"
+// This is needed as clients may override the target platform
+// using SkUserConfig
+#include "include/private/base/SkLoadUserConfig.h"
 
 #if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
 

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

@@ -48,7 +48,6 @@ SK_API void SkTypeface_SetEnsureLOGFONTAccessibleProc(void (*)(const LOGFONT&));
 // Experimental!
 //
 class SkFontMgr;
-class SkRemotableFontMgr;
 struct IDWriteFactory;
 struct IDWriteFontCollection;
 struct IDWriteFontFallback;
@@ -60,21 +59,5 @@ SK_API sk_sp<SkFontMgr> SkFontMgr_New_DirectWrite(IDWriteFactory* factory,
                                                   IDWriteFontCollection* collection,
                                                   IDWriteFontFallback* fallback);
 
-/**
- *  Creates an SkFontMgr which renders using DirectWrite and obtains its data
- *  from the SkRemotableFontMgr.
- *
- *  If DirectWrite could not be initialized, will return NULL.
- */
-SK_API sk_sp<SkFontMgr> SkFontMgr_New_DirectWriteRenderer(sk_sp<SkRemotableFontMgr>);
-
-/**
- *  Creates an SkRemotableFontMgr backed by DirectWrite using the default
- *  system font collection in the current locale.
- *
- *  If DirectWrite could not be initialized, will return NULL.
- */
-SK_API sk_sp<SkRemotableFontMgr> SkRemotableFontMgr_New_DirectWrite();
-
 #endif  // SK_BUILD_FOR_WIN
 #endif  // SkTypeface_win_DEFINED

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

@@ -15,6 +15,7 @@
 #include "include/core/SkImageInfo.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkTypes.h"
+#include "include/private/base/SkTo.h"
 #include "modules/skcms/skcms.h"
 
 #include <cstdint>
@@ -165,8 +166,13 @@ public:
                 break;
         }
 
-        return SkEncodedInfo(width, height, color, alpha,
-                bitsPerComponent, colorDepth, std::move(profile));
+        return SkEncodedInfo(width,
+                             height,
+                             color,
+                             alpha,
+                             SkToU8(bitsPerComponent),
+                             SkToU8(colorDepth),
+                             std::move(profile));
     }
 
     /*

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

@@ -9,94 +9,47 @@
 #define SkExif_DEFINED
 
 #include "include/codec/SkEncodedOrigin.h"
-#include "include/core/SkData.h"
-#include "include/core/SkRefCnt.h"
 #include "include/private/base/SkAPI.h"
 
 #include <cstdint>
+#include <optional>
 
-class SK_API SkExifMetadata {
-public:
-    /*
-     * Parse the metadata specified in |data|.
-     */
-    SkExifMetadata(const sk_sp<SkData> data);
+class SkData;
 
-    /*
-     * If the image encoded origin is specified, populate |out| and return true. Otherwise return
-     * false.
-     */
-    bool getOrigin(SkEncodedOrigin* out) const {
-        if (fOriginPresent && out) *out = fOriginValue;
-        return fOriginPresent;
-    }
+namespace SkExif {
 
-    /*
-     * If the HDR headroom is specified, populate |out| and return true. Otherwise return false.
-     */
-    bool getHdrHeadroom(float* out) const {
-        if (fHdrHeadroomPresent && out) *out = fHdrHeadroomValue;
-        return fHdrHeadroomPresent;
-    }
+// Tag values that are parsed by Parse and stored in Metadata.
+static constexpr uint16_t kOriginTag = 0x112;
+static constexpr uint16_t kResolutionUnitTag = 0x0128;
+static constexpr uint16_t kXResolutionTag = 0x011a;
+static constexpr uint16_t kYResolutionTag = 0x011b;
+static constexpr uint16_t kPixelXDimensionTag = 0xa002;
+static constexpr uint16_t kPixelYDimensionTag = 0xa003;
 
-    /*
-     * If resolution unit, x, or y is specified, populate |out| and return true. Otherwise return
-     * false.
-     */
-    bool getResolutionUnit(uint16_t* out) const {
-        if (fResolutionUnitPresent && out) *out = fResolutionUnitValue;
-        return fResolutionUnitPresent;
-    }
-    bool getXResolution(float* out) const {
-        if (fXResolutionPresent && out) *out = fXResolutionValue;
-        return fXResolutionPresent;
-    }
-    bool getYResolution(float* out) const {
-        if (fYResolutionPresent && out) *out = fYResolutionValue;
-        return fYResolutionPresent;
-    }
-
-    /*
-     * If pixel dimension x or y is specified, populate |out| and return true. Otherwise return
-     * false.
-     */
-    bool getPixelXDimension(uint32_t* out) const {
-        if (fPixelXDimensionPresent && out) *out = fPixelXDimensionValue;
-        return fPixelXDimensionPresent;
-    }
-    bool getPixelYDimension(uint32_t* out) const {
-        if (fPixelYDimensionPresent && out) *out = fPixelYDimensionValue;
-        return fPixelYDimensionPresent;
-    }
-
-private:
-    // Helper functions and constants for parsing the data.
-    void parseIfd(uint32_t ifdOffset, bool littleEndian, bool isRoot);
-
-    // The input data.
-    const sk_sp<SkData> fData;
-
-    // The origin property.
-    bool fOriginPresent = false;
-    SkEncodedOrigin fOriginValue = kTopLeft_SkEncodedOrigin;
+struct Metadata {
+    // The image orientation.
+    std::optional<SkEncodedOrigin> fOrigin;
 
     // The HDR headroom property.
-    bool fHdrHeadroomPresent = false;
-    float fHdrHeadroomValue = 1.f;
+    // https://developer.apple.com/documentation/appkit/images_and_pdf/applying_apple_hdr_effect_to_your_photos
+    std::optional<float> fHdrHeadroom;
 
     // Resolution.
-    bool fResolutionUnitPresent = false;
-    uint16_t fResolutionUnitValue = 0;
-    bool fXResolutionPresent = false;
-    float fXResolutionValue = 0;
-    bool fYResolutionPresent = false;
-    float fYResolutionValue = 0;
+    std::optional<uint16_t> fResolutionUnit;
+    std::optional<float> fXResolution;
+    std::optional<float> fYResolution;
 
     // Size in pixels.
-    bool fPixelXDimensionPresent = false;
-    uint32_t fPixelXDimensionValue = 0;
-    bool fPixelYDimensionPresent = false;
-    uint32_t fPixelYDimensionValue = 0;
+    std::optional<uint32_t> fPixelXDimension;
+    std::optional<uint32_t> fPixelYDimension;
 };
 
+/*
+ * Parse the metadata specified in |data| and write them to |metadata|. Stop only at an
+ * unrecoverable error (allow truncated input).
+ */
+void SK_API Parse(Metadata& metadata, const SkData* data);
+
+}  // namespace SkExif
+
 #endif

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

@@ -10,6 +10,8 @@
 
 #include "include/core/SkColor.h"
 #include "include/core/SkColorSpace.h"
+#include "include/core/SkRefCnt.h"
+class SkData;
 
 /**
  *  Gainmap rendering parameters. Suppose our display has HDR to SDR ratio of H and we wish to
@@ -72,29 +74,67 @@ struct SkGainmapInfo {
     };
     BaseImageType fBaseImageType = BaseImageType::kSDR;
 
+    /**
+     *  The type of the gainmap image. If the type is kApple, then the gainmap image was originally
+     *  encoded according to the specification at [0], and can be converted to the kDefault type by
+     *  applying the transformation described at [1].
+     *  [0] https://developer.apple.com/documentation/appkit/images_and_pdf/
+     *      applying_apple_hdr_effect_to_your_photos
+     *  [1] https://docs.google.com/document/d/1iUpYAThVV_FuDdeiO3t0vnlfoA1ryq0WfGS9FuydwKc
+     */
+    enum class Type {
+        kDefault,
+        kApple,
+    };
+    Type fType = Type::kDefault;
+
     /**
      * If specified, color space to apply the gainmap in, otherwise the base image's color space
      * is used. Only the color primaries are used, the transfer function is irrelevant.
      */
     sk_sp<SkColorSpace> fGainmapMathColorSpace = nullptr;
 
+    /**
+     * Return true if this can be encoded as an UltraHDR v1 image.
+     */
+    bool isUltraHDRv1Compatible() const;
+
+    /**
+     * If |data| contains an ISO 21496-1 version that is supported, return true. Otherwise return
+     * false.
+     */
+    static bool ParseVersion(const SkData* data);
+
+    /**
+     * If |data| constains ISO 21496-1 metadata then parse that metadata then use it to populate
+     * |info| and return true, otherwise return false. If |data| indicates that that the base image
+     * color space primaries should be used for gainmap application then set
+     * |fGainmapMathColorSpace| to nullptr, otherwise set |fGainmapMathColorSpace| to sRGB (the
+     * default, to be overwritten by the image decoder).
+     */
+    static bool Parse(const SkData* data, SkGainmapInfo& info);
+
+    /**
+     * Serialize an ISO 21496-1 version 0 blob containing only the version structure.
+     */
+    static sk_sp<SkData> SerializeVersion();
+
+    /**
+     * Serialize an ISO 21496-1 version 0 blob containing this' gainmap parameters.
+     */
+    sk_sp<SkData> serialize() const;
+
     inline bool operator==(const SkGainmapInfo& other) const {
         return fGainmapRatioMin == other.fGainmapRatioMin &&
                fGainmapRatioMax == other.fGainmapRatioMax && fGainmapGamma == other.fGainmapGamma &&
                fEpsilonSdr == other.fEpsilonSdr && fEpsilonHdr == other.fEpsilonHdr &&
                fDisplayRatioSdr == other.fDisplayRatioSdr &&
                fDisplayRatioHdr == other.fDisplayRatioHdr &&
-               fBaseImageType == other.fBaseImageType &&
+               fBaseImageType == other.fBaseImageType && fType == other.fType &&
                SkColorSpace::Equals(fGainmapMathColorSpace.get(),
                                     other.fGainmapMathColorSpace.get());
     }
     inline bool operator!=(const SkGainmapInfo& other) const { return !(*this == other); }
-
-    // TODO(ccameron): Remove these parameters once we are certain they are not used in Android.
-    enum class Type {
-        kDefault,
-    };
-    Type fType = Type::kDefault;
 };
 
 #endif

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

@@ -47,6 +47,11 @@ public:
      */
     static std::unique_ptr<SkJpegMetadataDecoder> Make(std::vector<Segment> headerSegments);
 
+    /**
+     * Create metadata for the specified encoded JPEG file. This may return nullptr.
+     */
+    static std::unique_ptr<SkJpegMetadataDecoder> Make(sk_sp<SkData> data);
+
     /**
      * Return the Exif data attached to the image (if any) and nullptr otherwise. If |copyData| is
      * false, then the returned SkData may directly reference the data provided when this object was
@@ -61,6 +66,13 @@ public:
      */
     virtual sk_sp<SkData> getICCProfileData(bool copyData) const = 0;
 
+    /**
+     * Return the ISO 21496-1 metadata, if any, and nullptr otherwise. If |copyData| is false,
+     * then the returned SkData may directly reference the data provided when this object was
+     * created.
+     */
+    virtual sk_sp<SkData> getISOGainmapMetadata(bool copyData) const = 0;
+
     /**
      * Return true if there is a possibility that this image contains a gainmap image.
      */

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

@@ -15,6 +15,7 @@
 #include "include/core/SkTypes.h"
 #include "include/private/SkIDChangeListener.h"
 #include "include/private/base/SkDebug.h"
+#include "include/private/base/SkSpan_impl.h"
 #include "include/private/base/SkTArray.h"
 #include "include/private/base/SkTo.h"
 
@@ -22,7 +23,6 @@
 #include <cstddef>
 #include <cstdint>
 #include <tuple>
-#include <utility>
 
 class SkMatrix;
 class SkRRect;
@@ -59,18 +59,23 @@ public:
     using VerbsArray = skia_private::STArray<4, uint8_t>;
     using ConicWeightsArray = skia_private::STArray<2, SkScalar>;
 
-    SkPathRef(PointsArray points, VerbsArray verbs, ConicWeightsArray weights,
-              unsigned segmentMask)
-        : fPoints(std::move(points))
-        , fVerbs(std::move(verbs))
-        , fConicWeights(std::move(weights))
+    enum class PathType : uint8_t {
+        kGeneral,
+        kOval,
+        kRRect,
+    };
+
+    SkPathRef(SkSpan<const SkPoint> points, SkSpan<const uint8_t> verbs,
+              SkSpan<const SkScalar> weights, unsigned segmentMask)
+        : fPoints(points)
+        , fVerbs(verbs)
+        , fConicWeights(weights)
     {
         fBoundsIsDirty = true;    // this also invalidates fIsFinite
         fGenerationID = 0;        // recompute
         fSegmentMask = segmentMask;
-        fIsOval = false;
-        fIsRRect = false;
-        // The next two values don't matter unless fIsOval or fIsRRect are true.
+        fType = PathType::kGeneral;
+        // The next two values don't matter unless fType is kOval or kRRect
         fRRectOrOvalIsCCW = false;
         fRRectOrOvalStartIdx = 0xAC;
         SkDEBUGCODE(fEditorsAttached.store(0);)
@@ -83,7 +88,8 @@ public:
     public:
         Editor(sk_sp<SkPathRef>* pathRef,
                int incReserveVerbs = 0,
-               int incReservePoints = 0);
+               int incReservePoints = 0,
+               int incReserveConics = 0);
 
         ~Editor() { SkDEBUGCODE(fPathRef->fEditorsAttached--;) }
 
@@ -146,12 +152,12 @@ public:
          */
         SkPathRef* pathRef() { return fPathRef; }
 
-        void setIsOval(bool isOval, bool isCCW, unsigned start) {
-            fPathRef->setIsOval(isOval, isCCW, start);
+        void setIsOval(bool isCCW, unsigned start) {
+            fPathRef->setIsOval(isCCW, start);
         }
 
-        void setIsRRect(bool isRRect, bool isCCW, unsigned start) {
-            fPathRef->setIsRRect(isRRect, isCCW, start);
+        void setIsRRect(bool isCCW, unsigned start) {
+            fPathRef->setIsRRect(isCCW, start);
         }
 
         void setBounds(const SkRect& rect) { fPathRef->setBounds(rect); }
@@ -226,7 +232,7 @@ public:
      *              fact ovals can report false.
      */
     bool isOval(SkRect* rect, bool* isCCW, unsigned* start) const {
-        if (fIsOval) {
+        if (fType == PathType::kOval) {
             if (rect) {
                 *rect = this->getBounds();
             }
@@ -238,7 +244,7 @@ public:
             }
         }
 
-        return SkToBool(fIsOval);
+        return fType == PathType::kOval;
     }
 
     bool isRRect(SkRRect* rrect, bool* isCCW, unsigned* start) const;
@@ -351,13 +357,12 @@ private:
         kSegmentMask_SerializationShift = 0                 // requires 4 bits (deprecated)
     };
 
-    SkPathRef(int numVerbs = 0, int numPoints = 0) {
+    SkPathRef(int numVerbs = 0, int numPoints = 0, int numConics = 0) {
         fBoundsIsDirty = true;    // this also invalidates fIsFinite
         fGenerationID = kEmptyGenID;
         fSegmentMask = 0;
-        fIsOval = false;
-        fIsRRect = false;
-        // The next two values don't matter unless fIsOval or fIsRRect are true.
+        fType = PathType::kGeneral;
+        // The next two values don't matter unless fType is kOval or kRRect
         fRRectOrOvalIsCCW = false;
         fRRectOrOvalStartIdx = 0xAC;
         if (numPoints > 0) {
@@ -366,11 +371,14 @@ private:
         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);
+    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) {
@@ -396,14 +404,19 @@ private:
     }
 
     /** Makes additional room but does not change the counts or change the genID */
-    void incReserve(int additionalVerbs, int additionalPoints) {
+    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)
+        if (additionalPoints > 0) {
             fPoints.reserve(fPoints.size() + additionalPoints);
-        if (additionalVerbs > 0)
+        }
+        if (additionalVerbs > 0) {
             fVerbs.reserve(fVerbs.size() + additionalVerbs);
+        }
+        if (additionalConics > 0) {
+            fConicWeights.reserve(fConicWeights.size() + additionalConics);
+        }
         SkDEBUGCODE(this->validate();)
     }
 
@@ -418,14 +431,14 @@ private:
         fGenerationID = 0;
 
         fSegmentMask = 0;
-        fIsOval = false;
-        fIsRRect = false;
+        fType = PathType::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 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);
@@ -434,6 +447,7 @@ private:
         fVerbs.reserve_exact(verbCount + reserveVerbs);
         fVerbs.resize_back(verbCount);
 
+        fConicWeights.reserve_exact(conicCount + reserveConics);
         fConicWeights.resize_back(conicCount);
         SkDEBUGCODE(this->validate();)
     }
@@ -471,14 +485,14 @@ private:
      */
     friend SkPathRef* sk_create_empty_pathref();
 
-    void setIsOval(bool isOval, bool isCCW, unsigned start) {
-        fIsOval = isOval;
+    void setIsOval(bool isCCW, unsigned start) {
+        fType = PathType::kOval;
         fRRectOrOvalIsCCW = isCCW;
         fRRectOrOvalStartIdx = SkToU8(start);
     }
 
-    void setIsRRect(bool isRRect, bool isCCW, unsigned start) {
-        fIsRRect = isRRect;
+    void setIsRRect(bool isCCW, unsigned start) {
+        fType = PathType::kRRect;
         fRRectOrOvalIsCCW = isCCW;
         fRRectOrOvalStartIdx = SkToU8(start);
     }
@@ -486,8 +500,7 @@ private:
     // called only by the editor. Note that this is not a const function.
     SkPoint* getWritablePoints() {
         SkDEBUGCODE(this->validate();)
-        fIsOval = false;
-        fIsRRect = false;
+        fType = PathType::kGeneral;
         return fPoints.begin();
     }
 
@@ -498,29 +511,24 @@ private:
 
     void callGenIDChangeListeners();
 
+    mutable SkRect   fBounds;
+
     enum {
-        kMinSize = 256,
+        kEmptyGenID = 1, // GenID reserved for path ref with zero points and zero verbs.
     };
-
-    mutable SkRect   fBounds;
+    mutable uint32_t    fGenerationID;
+    SkIDChangeListener::List fGenIDChangeListeners;
 
     PointsArray fPoints;
     VerbsArray fVerbs;
     ConicWeightsArray fConicWeights;
 
-    enum {
-        kEmptyGenID = 1, // GenID reserved for path ref with zero points and zero verbs.
-    };
-    mutable uint32_t    fGenerationID;
     SkDEBUGCODE(std::atomic<int> fEditorsAttached;) // assert only one editor in use at any time.
 
-    SkIDChangeListener::List fGenIDChangeListeners;
-
     mutable uint8_t  fBoundsIsDirty;
     mutable bool     fIsFinite;    // only meaningful if bounds are valid
 
-    bool     fIsOval;
-    bool     fIsRRect;
+    PathType fType;
     // 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;

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

@@ -35,10 +35,19 @@ public:
     static std::unique_ptr<SkXmp> Make(sk_sp<SkData> xmpStandard, sk_sp<SkData> xmpExtended);
 
     // Extract HDRGM gainmap parameters.
-    virtual bool getGainmapInfoHDRGM(SkGainmapInfo* info) const = 0;
-
-    // Extract HDRGainMap gainmap parameters.
-    virtual bool getGainmapInfoHDRGainMap(SkGainmapInfo* info) const = 0;
+    // TODO(b/338342146): Remove this once all callers are removed.
+    bool getGainmapInfoHDRGM(SkGainmapInfo* info) const { return getGainmapInfoAdobe(info); }
+
+    // Extract gainmap parameters from http://ns.adobe.com/hdr-gain-map/1.0/.
+    virtual bool getGainmapInfoAdobe(SkGainmapInfo* info) const = 0;
+
+    // If the image specifies http://ns.apple.com/pixeldatainfo/1.0/ AuxiliaryImageType of
+    // urn:com:apple:photo:2020:aux:hdrgainmap, and includes a http://ns.apple.com/HDRGainMap/1.0/
+    // HDRGainMapVersion, then populate |info| with gainmap parameters that will approximate the
+    // math specified at [0] and return true.
+    // [0] https://developer.apple.com/documentation/appkit/images_and_pdf/
+    //     applying_apple_hdr_effect_to_your_photos
+    virtual bool getGainmapInfoApple(float exifHdrHeadroom, SkGainmapInfo* info) const = 0;
 
     // If this includes GContainer metadata and the GContainer contains an item with semantic
     // GainMap and Mime of image/jpeg, then return true, and populate |offset| and |size| with