@shopify/react-native-skia 0.1.196 → 0.1.199

package/cpp/skia/include/gpu/graphite/Image.h

@@ -0,0 +1,277 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_Image_DEFINED
+#define skgpu_graphite_Image_DEFINED
+
+#include "include/core/SkImage.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSpan.h"
+
+class SkYUVAInfo;
+class SkYUVAPixmaps;
+struct SkIRect;
+
+namespace skgpu::graphite {
+    class BackendTexture;
+    class Recorder;
+    class TextureInfo;
+    class YUVABackendTextureInfo;
+    class YUVABackendTextures;
+    enum class Volatile : bool;
+}
+
+namespace SkImages {
+using TextureReleaseProc = void (*)(ReleaseContext);
+
+// Passed to both non-YUVA fulfill and imageRelease
+using GraphitePromiseImageContext = void*;
+// Passed to YUVA fulfill
+using GraphitePromiseTextureContext = void*;
+// Returned from fulfill and passed into textureRelease
+using GraphitePromiseTextureReleaseContext = void*;
+
+using GraphitePromiseImageFulfillProc =
+        std::tuple<skgpu::graphite::BackendTexture, GraphitePromiseTextureReleaseContext> (*)(
+                GraphitePromiseImageContext);
+using GraphitePromiseImageYUVAFulfillProc =
+        std::tuple<skgpu::graphite::BackendTexture, GraphitePromiseTextureReleaseContext> (*)(
+                GraphitePromiseTextureContext);
+using GraphitePromiseImageReleaseProc = void (*)(GraphitePromiseImageContext);
+using GraphitePromiseTextureReleaseProc = void (*)(GraphitePromiseTextureReleaseContext);
+
+/** Creates an SkImage from a GPU texture associated with the recorder.
+
+    SkImage is returned if the format of backendTexture is recognized and supported.
+    Recognized formats vary by GPU back-end.
+
+    @param recorder            The recorder
+    @param backendTexture      texture residing on GPU
+    @param colorSpace          This describes the color space of this image's contents, as
+                               seen after sampling. In general, if the format of the backend
+                               texture is SRGB, some linear colorSpace should be supplied
+                               (e.g., SkColorSpace::MakeSRGBLinear()). If the format of the
+                               backend texture is linear, then the colorSpace should include
+                               a description of the transfer function as
+                               well (e.g., SkColorSpace::MakeSRGB()).
+    @return                    created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> AdoptTextureFrom(skgpu::graphite::Recorder*,
+                                       const skgpu::graphite::BackendTexture&,
+                                       SkColorType colorType,
+                                       SkAlphaType alphaType,
+                                       sk_sp<SkColorSpace> colorSpace,
+                                       TextureReleaseProc = nullptr,
+                                       ReleaseContext = nullptr);
+
+/** Create a new SkImage that is very similar to an SkImage created by
+    AdoptTextureFrom. The difference is that the caller need not have created the
+    backend texture nor populated it with data when creating the image. Instead of passing a
+    BackendTexture to the factory the client supplies a description of the texture consisting
+    of dimensions, TextureInfo, SkColorInfo and Volatility.
+
+    In general, 'fulfill' must return a BackendTexture that matches the properties
+    provided at SkImage creation time. The BackendTexture must refer to a valid existing
+    texture in the backend API context/device, and already be populated with data.
+    The texture cannot be deleted until 'textureRelease' is called. 'textureRelease' will
+    be called with the textureReleaseContext returned by 'fulfill'.
+
+    Wrt when and how often the fulfill, imageRelease, and textureRelease callbacks will
+    be called:
+
+    For non-volatile promise images, 'fulfill' will be called at Context::insertRecording
+    time. Regardless of whether 'fulfill' succeeded or failed, 'imageRelease' will always be
+    called only once - when Skia will no longer try calling 'fulfill' to get a backend
+    texture. If 'fulfill' failed (i.e., it didn't return a valid backend texture) then
+    'textureRelease' will never be called. If 'fulfill' was successful then
+    'textureRelease' will be called only once when the GPU is done with the contents of the
+    promise image. This will usually occur during a Context::submit call but it could occur
+    earlier due to error conditions. 'fulfill' can be called multiple times if the promise
+    image is used in multiple recordings. If 'fulfill' fails, the insertRecording itself will
+    fail. Subsequent insertRecording calls (with Recordings that use the promise image) will
+    keep calling 'fulfill' until it succeeds.
+
+    For volatile promise images, 'fulfill' will be called each time the Recording is inserted
+    into a Context. Regardless of whether 'fulfill' succeeded or failed, 'imageRelease'
+    will always be called only once just like the non-volatile case. If 'fulfill' fails at
+    insertRecording-time, 'textureRelease' will never be called. If 'fulfill' was successful
+    then a 'textureRelease' matching that 'fulfill' will be called when the GPU is done with
+    the contents of the promise image. This will usually occur during a Context::submit call
+    but it could occur earlier due to error conditions.
+
+    @param recorder       the recorder that will capture the commands creating the image
+    @param dimensions     width & height of promised gpu texture
+    @param textureInfo    structural information for the promised gpu texture
+    @param colorInfo      color type, alpha type and colorSpace information for the image
+    @param isVolatile     volatility of the promise image
+    @param fulfill        function called to get the actual backend texture,
+                          and the instance for the GraphitePromiseTextureReleaseProc
+    @param imageRelease   function called when any image-centric data can be deleted
+    @param textureRelease function called when the backend texture can be deleted
+    @param imageContext   state passed to fulfill and imageRelease
+    @return               created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> PromiseTextureFrom(skgpu::graphite::Recorder*,
+                                         SkISize dimensions,
+                                         const skgpu::graphite::TextureInfo&,
+                                         const SkColorInfo&,
+                                         skgpu::graphite::Volatile,
+                                         GraphitePromiseImageFulfillProc,
+                                         GraphitePromiseImageReleaseProc,
+                                         GraphitePromiseTextureReleaseProc,
+                                         GraphitePromiseImageContext);
+
+/** This is similar to 'PromiseTextureFrom' but it creates a GPU-backed SkImage from YUV[A] data.
+    The source data may be planar (i.e. spread across multiple textures). In
+    the extreme Y, U, V, and A are all in different planes and thus the image is specified by
+    four textures. 'backendTextureInfo' describes the planar arrangement, texture formats,
+    and conversion to RGB. Separate 'fulfill' and 'textureRelease' calls are made for each texture.
+    Each texture has its own GraphitePromiseTextureContext. The GraphitePromiseImageReleaseProc
+    will be made even on failure. 'textureContexts' has one entry for each of the up to four
+    textures, as indicated by 'backendTextureInfo'. Currently the mipmapped property of
+    'backendTextureInfo' is ignored. However, in the near future it will be required that if it is
+    kYes then the fulfillProc must return a mip mapped texture for each plane in order to
+    successfully draw the image.
+    @param recorder            the recorder that will capture the commands creating the image
+    @param backendTextureInfo  info about the promised yuva gpu texture(s)
+    @param imageColorSpace     range of colors; may be nullptr
+    @param isVolatile          volatility of the promise image
+    @param fulfill             function called to get the actual backend texture for
+                               a given GraphitePromiseTextureContext, and the instance
+                               for the GraphitePromiseTextureReleaseProc
+    @param imageRelease        function called when any image-centric data can be deleted
+    @param textureRelease      function called when the backend texture can be deleted
+    @param imageContext        state passed to imageRelease
+    @param textureContexts     states passed to fulfill and textureRelease
+    @return                    created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> PromiseTextureFromYUVA(skgpu::graphite::Recorder*,
+                                             const skgpu::graphite::YUVABackendTextureInfo&,
+                                             sk_sp<SkColorSpace> imageColorSpace,
+                                             skgpu::graphite::Volatile,
+                                             GraphitePromiseImageYUVAFulfillProc,
+                                             GraphitePromiseImageReleaseProc,
+                                             GraphitePromiseTextureReleaseProc,
+                                             GraphitePromiseImageContext imageContext,
+                                             GraphitePromiseTextureContext textureContexts[]);
+
+
+/** Returns an SkImage backed by a Graphite texture, using the provided Recorder for creation
+    and uploads if necessary. The returned SkImage respects the required image properties'
+    mipmap setting for non-Graphite SkImages; i.e., if mipmapping is required, the backing
+    Graphite texture will have allocated mip map levels.
+
+    It is assumed that MIP maps are always supported by the GPU.
+
+    Returns original SkImage if the image is already Graphite-backed and the required mipmapping
+    is compatible with the backing Graphite texture. If the required mipmapping is not
+    compatible, nullptr will be returned.
+
+    Returns nullptr if no Recorder is provided, or if SkImage was created with another
+    Recorder and work on that Recorder has not been submitted.
+
+    @param Recorder            the Recorder to use for storing commands
+    @param RequiredProperties  properties the returned SkImage must possess (e.g. mipmaps)
+    @return                    created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> TextureFromImage(skgpu::graphite::Recorder*,
+                                       const SkImage*,
+                                       SkImage::RequiredProperties = {});
+
+inline sk_sp<SkImage> TextureFromImage(skgpu::graphite::Recorder* r,
+                                       sk_sp<const SkImage> img,
+                                       SkImage::RequiredProperties props = {}) {
+    return TextureFromImage(r, img.get(), props);
+}
+
+/** Creates SkImage from SkYUVAPixmaps.
+
+    The image will remain planar with each plane converted to a texture using the passed
+    Recorder.
+
+    SkYUVAPixmaps has a SkYUVAInfo which specifies the transformation from YUV to RGB.
+    The SkColorSpace of the resulting RGB values is specified by imgColorSpace. This will
+    be the SkColorSpace reported by the image and when drawn the RGB values will be converted
+    from this space into the destination space (if the destination is tagged).
+
+    This is only supported using the GPU backend and will fail if recorder is nullptr.
+
+    SkYUVAPixmaps does not need to remain valid after this returns.
+
+    @param Recorder                 The Recorder to use for storing commands
+    @param pixmaps                  The planes as pixmaps with supported SkYUVAInfo that
+                                    specifies conversion to RGB.
+    @param RequiredProperties       Properties the returned SkImage must possess (e.g. mipmaps)
+    @param limitToMaxTextureSize    Downscale image to GPU maximum texture size, if necessary
+    @param imgColorSpace            Range of colors of the resulting image; may be nullptr
+    @return                         Created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> TextureFromYUVAPixmaps(skgpu::graphite::Recorder*,
+                                             const SkYUVAPixmaps& pixmaps,
+                                             SkImage::RequiredProperties = {},
+                                             bool limitToMaxTextureSize = false,
+                                             sk_sp<SkColorSpace> imgColorSpace = nullptr);
+
+/** Creates an SkImage from YUV[A] planar textures associated with the recorder.
+     @param recorder            The recorder.
+     @param yuvaBackendTextures A set of textures containing YUVA data and a description of the
+                                data and transformation to RGBA.
+     @param imageColorSpace     range of colors of the resulting image after conversion to RGB;
+                                may be nullptr
+     @param TextureReleaseProc  called when the backend textures can be released
+     @param ReleaseContext      state passed to TextureReleaseProc
+     @return                    created SkImage, or nullptr
+ */
+SK_API sk_sp<SkImage> TextureFromYUVATextures(
+        skgpu::graphite::Recorder* recorder,
+        const skgpu::graphite::YUVABackendTextures& yuvaBackendTextures,
+        sk_sp<SkColorSpace> imageColorSpace,
+        TextureReleaseProc = nullptr,
+        ReleaseContext = nullptr);
+
+/** Creates an SkImage from YUV[A] planar SkImages associated with the recorder.
+
+    The images should have kGraphite type, and the result will be nullptr if any are not.
+    The resulting SkImage will not take a ref on the given SkImages but will take a ref on
+    the underlying TextureProxies. The releaseProcs, if any, for those Textures will be the
+    ones set when the given SkImages were created.
+
+     @param recorder            The recorder.
+     @param yuvaInfo            Structure describing the YUVA format
+     @param images              A set of SkImages containing YUVA data
+     @param imageColorSpace     Range of colors of the resulting image after conversion to RGB;
+                                may be nullptr
+     @return                    created SkImage, or nullptr
+ */
+SK_API sk_sp<SkImage> TextureFromYUVAImages(
+        skgpu::graphite::Recorder* recorder,
+        const SkYUVAInfo& yuvaInfo,
+        SkSpan<const sk_sp<SkImage>> images,
+        sk_sp<SkColorSpace> imageColorSpace);
+
+/** Returns subset of this image as a texture-backed image.
+
+    Returns nullptr if any of the following are true:
+      - Subset is empty
+      - Subset is not contained inside the image's bounds
+      - Pixels in the source image could not be read or copied
+      - The source image is texture-backed and context does not match the source image's context.
+
+    @param recorder the non-null recorder in which to create the new image.
+    @param img     Source image
+    @param subset  bounds of returned SkImage
+    @param props   properties the returned SkImage must possess (e.g. mipmaps)
+    @return        the subsetted image, uploaded as a texture, or nullptr
+*/
+SK_API sk_sp<SkImage> SubsetTextureFrom(skgpu::graphite::Recorder* recorder,
+                                        const SkImage* img,
+                                        const SkIRect& subset,
+                                        SkImage::RequiredProperties props = {});
+} // namespace SkImages
+
+
+#endif // skgpu_graphite_Image_DEFINED

package/cpp/skia/include/gpu/graphite/ImageProvider.h

@@ -55,7 +55,7 @@ public:
     // which could then be cached.
     virtual sk_sp<SkImage> findOrCreate(Recorder* recorder,
                                         const SkImage* image,
-                                        SkImage::RequiredImageProperties) = 0;
+                                        SkImage::RequiredProperties) = 0;
 };
 
 } // namespace skgpu::graphite

package/cpp/skia/include/gpu/graphite/Recording.h

@@ -9,7 +9,6 @@
 #define skgpu_graphite_Recording_DEFINED
 
 #include "include/core/SkRefCnt.h"
-#include "include/private/SkChecksum.h"
 #include "include/private/base/SkTArray.h"
 
 #include <memory>
@@ -62,9 +61,7 @@ private:
     };
 
     struct ProxyHash {
-        std::size_t operator()(const sk_sp<TextureProxy>& proxy) const {
-            return SkGoodHash()(proxy.get());
-        }
+        std::size_t operator()(const sk_sp<TextureProxy>& proxy) const;
     };
 
     Recording(std::unique_ptr<TaskGraph>,

package/cpp/skia/include/gpu/graphite/Surface.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_Surface_DEFINED
+#define skgpu_graphite_Surface_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSurface.h"
+#include "include/gpu/GpuTypes.h"
+
+class SkImage;
+struct SkImageInfo;
+
+namespace skgpu::graphite {
+class BackendTexture;
+class Recorder;
+}  // namespace skgpu::graphite
+
+namespace SkSurfaces {
+/**
+ * The 'asImage' and 'makeImageCopy' API/entry points are currently only available for
+ * Graphite.
+ *
+ * In this API, SkSurface no longer supports copy-on-write behavior. Instead, when creating
+ * an image for a surface, the client must explicitly indicate if a copy should be made.
+ * In both of the below calls the resource backing the surface will never change.
+ *
+ * The 'AsImage' entry point has some major ramifications for the mutability of the
+ * returned SkImage. Since the originating surface and the returned image share the
+ * same backing, care must be taken by the client to ensure that the contents of the image
+ * reflect the desired contents when it is consumed by the gpu.
+ * Note: if the backing GPU buffer isn't textureable this method will return null. Graphite
+ * will not attempt to make a copy.
+ * Note: For 'AsImage', the mipmapping of the image will match that of the source surface.
+ *
+ * The 'AsImageCopy' entry point allows subsetting and the addition of mipmaps (since
+ * a copy is already being made).
+ *
+ * In Graphite, the legacy API call (i.e., makeImageSnapshot) will just always make a copy.
+ */
+SK_API sk_sp<SkImage> AsImage(sk_sp<const SkSurface>);
+SK_API sk_sp<SkImage> AsImageCopy(sk_sp<const SkSurface>,
+                                  const SkIRect* subset = nullptr,
+                                  skgpu::Mipmapped = skgpu::Mipmapped::kNo);
+
+/**
+ * In Graphite, while clients hold a ref on an SkSurface, the backing gpu object does _not_
+ * count against the budget. Once an SkSurface is freed, the backing gpu object may or may
+ * not become a scratch (i.e., reusable) resource but, if it does, it will be counted against
+ * the budget.
+ */
+SK_API sk_sp<SkSurface> RenderTarget(skgpu::graphite::Recorder*,
+                                     const SkImageInfo& imageInfo,
+                                     skgpu::Mipmapped = skgpu::Mipmapped::kNo,
+                                     const SkSurfaceProps* surfaceProps = nullptr);
+
+/**
+ * Wraps a GPU-backed texture in an SkSurface. Depending on the backend gpu API, the caller may
+ * be required to ensure the texture is valid for the lifetime of the returned SkSurface. The
+ * required lifetimes for the specific apis are:
+ *     Metal: Skia will call retain on the underlying MTLTexture so the caller can drop it once
+ *            this call returns.
+ *
+ * SkSurface is returned if all the parameters are valid. The backendTexture is valid if its
+ * format agrees with colorSpace and recorder; for instance, if backendTexture has an sRGB
+ * configuration, then the recorder must support sRGB, and colorSpace must be present. Further,
+ * backendTexture's width and height must not exceed the recorder's capabilities, and the
+ * recorder must be able to support the back-end texture.
+ */
+SK_API sk_sp<SkSurface> WrapBackendTexture(skgpu::graphite::Recorder*,
+                                           const skgpu::graphite::BackendTexture&,
+                                           SkColorType colorType,
+                                           sk_sp<SkColorSpace> colorSpace,
+                                           const SkSurfaceProps* props);
+}  // namespace SkSurfaces
+
+#endif  // skgpu_graphite_Surface_DEFINED

package/cpp/skia/include/gpu/graphite/TextureInfo.h

@@ -8,6 +8,7 @@
 #ifndef skgpu_graphite_TextureInfo_DEFINED
 #define skgpu_graphite_TextureInfo_DEFINED
 
+#include "include/core/SkString.h"
 #include "include/gpu/graphite/GraphiteTypes.h"
 
 #ifdef SK_DAWN
@@ -76,13 +77,7 @@ public:
     Protected isProtected() const { return fProtected; }
 
 #ifdef SK_DAWN
-    bool getDawnTextureInfo(DawnTextureInfo* info) const {
-        if (!this->isValid() || fBackend != BackendApi::kDawn) {
-            return false;
-        }
-        *info = DawnTextureSpecToTextureInfo(fDawnSpec, fSampleCount, fMipmapped);
-        return true;
-    }
+    bool getDawnTextureInfo(DawnTextureInfo* info) const;
 #endif
 
 #ifdef SK_METAL
@@ -105,6 +100,8 @@ public:
     }
 #endif
 
+    SkString toString() const;
+
 private:
 #ifdef SK_DAWN
     friend class DawnCaps;
@@ -154,6 +151,7 @@ private:
 #ifdef SK_VULKAN
         VulkanTextureSpec fVkSpec;
 #endif
+        void* fEnsureUnionNonEmpty;
     };
 };
 

package/cpp/skia/include/gpu/graphite/YUVABackendTextures.h

@@ -39,7 +39,7 @@ public:
      */
     YUVABackendTextureInfo(const Recorder*,
                            const SkYUVAInfo&,
-                           const TextureInfo[kMaxPlanes],
+                           SkSpan<const TextureInfo>,
                            Mipmapped);
 
     bool operator==(const YUVABackendTextureInfo&) const;
@@ -97,7 +97,7 @@ public:
      */
     YUVABackendTextures(const Recorder*,
                         const SkYUVAInfo&,
-                        const BackendTexture[kMaxPlanes]);
+                        SkSpan<const BackendTexture>);
 
     SkSpan<const BackendTexture> planeTextures() const {
         return SkSpan<const BackendTexture>(fPlaneTextures);

package/cpp/skia/include/gpu/mock/GrMockTypes.h

@@ -22,10 +22,12 @@ struct GrMockTextureInfo {
 
     GrMockTextureInfo(GrColorType colorType,
                       SkTextureCompressionType compressionType,
-                      int id)
+                      int id,
+                      skgpu::Protected isProtected = skgpu::Protected::kNo)
             : fColorType(colorType)
             , fCompressionType(compressionType)
-            , fID(id) {
+            , fID(id)
+            , fProtected(isProtected) {
         SkASSERT(fID);
         if (fCompressionType != SkTextureCompressionType::kNone) {
             SkASSERT(colorType == GrColorType::kUnknown);
@@ -35,7 +37,8 @@ struct GrMockTextureInfo {
     bool operator==(const GrMockTextureInfo& that) const {
         return fColorType == that.fColorType &&
                fCompressionType == that.fCompressionType &&
-               fID == that.fID;
+               fID == that.fID &&
+               fProtected == that.fProtected;
     }
 
     GrBackendFormat getBackendFormat() const;
@@ -49,10 +52,14 @@ struct GrMockTextureInfo {
 
     int id() const { return fID; }
 
+    skgpu::Protected getProtected() const { return fProtected; }
+    bool isProtected() const { return fProtected == skgpu::Protected::kYes; }
+
 private:
     GrColorType              fColorType;
     SkTextureCompressionType fCompressionType;
     int                      fID;
+    skgpu::Protected         fProtected = skgpu::Protected::kNo;
 };
 
 struct GrMockRenderTargetInfo {
@@ -60,24 +67,32 @@ struct GrMockRenderTargetInfo {
             : fColorType(GrColorType::kUnknown)
             , fID(0) {}
 
-    GrMockRenderTargetInfo(GrColorType colorType, int id)
+    GrMockRenderTargetInfo(GrColorType colorType,
+                           int id,
+                           skgpu::Protected isProtected = skgpu::Protected::kNo)
             : fColorType(colorType)
-            , fID(id) {
+            , fID(id)
+            , fProtected(isProtected) {
         SkASSERT(fID);
     }
 
     bool operator==(const GrMockRenderTargetInfo& that) const {
         return fColorType == that.fColorType &&
-               fID == that.fID;
+               fID == that.fID &&
+               fProtected == that.fProtected;
     }
 
     GrBackendFormat getBackendFormat() const;
 
     GrColorType colorType() const { return fColorType; }
 
+    skgpu::Protected getProtected() const { return fProtected; }
+    bool isProtected() const { return fProtected == skgpu::Protected::kYes; }
+
 private:
-    GrColorType   fColorType;
-    int           fID;
+    GrColorType      fColorType;
+    int              fID;
+    skgpu::Protected fProtected = skgpu::Protected::kNo;
 };
 
 struct GrMockSurfaceInfo {

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

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2023 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkTypeface_fontations_DEFINED
+#define SkTypeface_fontations_DEFINED
+
+#include "include/core/SkFontArguments.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypeface.h"
+#include "include/core/SkTypes.h"
+
+#include <memory>
+
+SK_API sk_sp<SkTypeface> SkTypeface_Make_Fontations(std::unique_ptr<SkStreamAsset> fontData,
+                                                    const SkFontArguments& args);
+
+#endif

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

@@ -34,6 +34,8 @@
  *  In the above math, log() is a natural logarithm and exp() is natural exponentiation. Note,
  *  however, that the base used for the log() and exp() functions does not affect the results of
  *  the computation (it cancels out, as long as the same base is used throughout).
+ *
+ *  This product includes Gain Map technology under license by Adobe.
  */
 struct SkGainmapInfo {
     /**

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

@@ -9,6 +9,7 @@
 #define SkGainmapShader_DEFINED
 
 #include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
 
 class SkColorSpace;
 class SkShader;

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

@@ -19,7 +19,6 @@ struct SkGainmapInfo;
 
 /**
  * An interface that can be used to extract metadata from an encoded JPEG file.
- * TODO(https://crbug.com/1404000): Add interface for ICC profile and EXIF extraction.
  */
 class SK_API SkJpegMetadataDecoder {
 public:
@@ -48,6 +47,25 @@ public:
      */
     static std::unique_ptr<SkJpegMetadataDecoder> Make(std::vector<Segment> headerSegments);
 
+    /**
+     * 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
+     * created.
+     */
+    virtual sk_sp<SkData> getExifMetadata(bool copyData) const = 0;
+
+    /**
+     * Return the ICC profile of 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
+     * created.
+     */
+    virtual sk_sp<SkData> getICCProfileData(bool copyData) const = 0;
+
+    /**
+     * Return true if there is a possibility that this image contains a gainmap image.
+     */
+    virtual bool mightHaveGainmapImage() const = 0;
+
     /**
      * Given a JPEG encoded image |baseImageData|, return in |outGainmapImageData| the JPEG encoded
      * gainmap image and return in |outGainmapInfo| its gainmap rendering parameters. Return true if

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

@@ -360,10 +360,12 @@ private:
         // The next two values don't matter unless fIsOval or fIsRRect are true.
         fRRectOrOvalIsCCW = false;
         fRRectOrOvalStartIdx = 0xAC;
-        if (numPoints > 0)
-            fPoints.reserve_back(numPoints);
-        if (numVerbs > 0)
-            fVerbs.reserve_back(numVerbs);
+        if (numPoints > 0) {
+            fPoints.reserve_exact(numPoints);
+        }
+        if (numVerbs > 0) {
+            fVerbs.reserve_exact(numVerbs);
+        }
         SkDEBUGCODE(fEditorsAttached.store(0);)
         SkDEBUGCODE(this->validate();)
     }
@@ -378,7 +380,7 @@ private:
     // called, if dirty, by getBounds()
     void computeBounds() const {
         SkDEBUGCODE(this->validate();)
-        // TODO(mtklein): remove fBoundsIsDirty and fIsFinite,
+        // TODO: remove fBoundsIsDirty and fIsFinite,
         // using an inverted rect instead of fBoundsIsDirty and always recalculating fIsFinite.
         SkASSERT(fBoundsIsDirty);
 
@@ -424,18 +426,14 @@ private:
      *  allocates space for reserveVerb additional verbs and reservePoints additional points.*/
     void resetToSize(int verbCount, int pointCount, int conicCount,
                      int reserveVerbs = 0, int reservePoints = 0) {
-        commonReset();
-        // Use reserve_back() so the arrays are sized to exactly fit the data.
-        const int pointDelta = pointCount + reservePoints - fPoints.size();
-        if (pointDelta > 0) {
-            fPoints.reserve_back(pointDelta);
-        }
+        this->commonReset();
+        // Use reserve_exact() so the arrays are sized to exactly fit the data.
+        fPoints.reserve_exact(pointCount + reservePoints);
         fPoints.resize_back(pointCount);
-        const int verbDelta = verbCount + reserveVerbs - fVerbs.size();
-        if (verbDelta > 0) {
-            fVerbs.reserve_back(verbDelta);
-        }
+
+        fVerbs.reserve_exact(verbCount + reserveVerbs);
         fVerbs.resize_back(verbCount);
+
         fConicWeights.resize_back(conicCount);
         SkDEBUGCODE(this->validate();)
     }