@shopify/react-native-skia 0.1.158 → 0.1.159

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

@@ -765,7 +765,22 @@ public:
         kGray_8_SkColorType or kRGB_565_SkColorType, then alpha is ignored; RGB is
         treated as opaque. If colorType() is kAlpha_8_SkColorType, then RGB is ignored.
 
-        @param c  unpremultiplied color
+        @param c            unpremultiplied color
+        @param colorSpace   SkColorSpace of c
+
+        example: https://fiddle.skia.org/c/@Bitmap_eraseColor
+    */
+    void eraseColor(SkColor4f c, SkColorSpace* colorSpace = nullptr) const;
+
+    /** Replaces pixel values with c, interpreted as being in the sRGB SkColorSpace.
+        All pixels contained by bounds() are affected. If the colorType() is
+        kGray_8_SkColorType or kRGB_565_SkColorType, then alpha is ignored; RGB is
+        treated as opaque. If colorType() is kAlpha_8_SkColorType, then RGB is ignored.
+
+        Input color is ultimately converted to an SkColor4f, so eraseColor(SkColor4f c)
+        will have higher color resolution.
+
+        @param c  unpremultiplied color.
 
         example: https://fiddle.skia.org/c/@Bitmap_eraseColor
     */
@@ -793,6 +808,25 @@ public:
         is ignored; RGB is treated as opaque. If colorType() is kAlpha_8_SkColorType,
         then RGB is ignored.
 
+        @param c            unpremultiplied color
+        @param area         rectangle to fill
+        @param colorSpace   SkColorSpace of c
+
+        example: https://fiddle.skia.org/c/@Bitmap_erase
+    */
+    void erase(SkColor4f c, SkColorSpace* colorSpace, const SkIRect& area) const;
+    void erase(SkColor4f c, const SkIRect& area) const;
+
+    /** Replaces pixel values inside area with c. interpreted as being in the sRGB
+        SkColorSpace. If area does not intersect bounds(), call has no effect.
+
+        If the colorType() is kGray_8_SkColorType or kRGB_565_SkColorType, then alpha
+        is ignored; RGB is treated as opaque. If colorType() is kAlpha_8_SkColorType,
+        then RGB is ignored.
+
+        Input color is ultimately converted to an SkColor4f, so erase(SkColor4f c)
+        will have higher color resolution.
+
         @param c     unpremultiplied color
         @param area  rectangle to fill
 
@@ -826,6 +860,23 @@ public:
         return this->pixmap().getColor(x, y);
     }
 
+    /** Returns pixel at (x, y) as unpremultiplied float color.
+        Returns black with alpha if SkColorType is kAlpha_8_SkColorType.
+
+        Input is not validated: out of bounds values of x or y trigger an assert() if
+        built with SK_DEBUG defined; and returns undefined values or may crash if
+        SK_RELEASE is defined. Fails if SkColorType is kUnknown_SkColorType or
+        pixel address is nullptr.
+
+        SkColorSpace in SkImageInfo is ignored. Some color precision may be lost in the
+        conversion to unpremultiplied color.
+
+        @param x  column index, zero or greater, and less than width()
+        @param y  row index, zero or greater, and less than height()
+        @return   pixel converted to unpremultiplied color
+    */
+    SkColor4f getColor4f(int x, int y) const { return this->pixmap().getColor4f(x, y); }
+
     /** Look up the pixel at (x,y) and return its alpha component, normalized to [0..1].
         This is roughly equivalent to SkGetColorA(getColor()), but can be more efficent
         (and more precise if the pixels store more than 8 bits per component).

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

@@ -73,6 +73,8 @@ enum class SkBlendMode {
     kLastMode          = kLuminosity, //!< last valid value
 };
 
+static constexpr int kSkBlendModeCount = static_cast<int>(SkBlendMode::kLastMode) + 1;
+
 /**
  * For Porter-Duff SkBlendModes (those <= kLastCoeffMode), these coefficients describe the blend
  * equation used. Coefficient-based blend modes specify an equation:

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

@@ -38,18 +38,20 @@
 #define SK_SUPPORT_LEGACY_GETTOTALMATRIX
 #endif
 
+namespace sktext {
+class GlyphRunBuilder;
+class GlyphRunList;
+}
+
 class AutoLayerForImageFilter;
 class GrBackendRenderTarget;
 class GrRecordingContext;
-class GrSlug;
 class SkBaseDevice;
 class SkBitmap;
 class SkData;
 class SkDrawable;
 struct SkDrawShadowRec;
 class SkFont;
-class SkGlyphRunBuilder;
-class SkGlyphRunList;
 class SkImage;
 class SkImageFilter;
 class SkPaintFilterCanvas;
@@ -67,8 +69,14 @@ class SkTextBlob;
 class SkVertices;
 
 namespace skgpu::graphite { class Recorder; }
+namespace sktext::gpu { class Slug; }
 namespace SkRecords { class Draw; }
 
+// TODO:
+// This is not ideal but Chrome is depending on a forward decl of GrSlug here.
+// It should be removed once Chrome has migrated to sktext::gpu::Slug.
+using GrSlug = sktext::gpu::Slug;
+
 /** \class SkCanvas
     SkCanvas provides an interface for drawing, and how the drawing is clipped and transformed.
     SkCanvas contains a stack of SkMatrix and clip values.
@@ -255,10 +263,27 @@ public:
         @param props  storage for writable SkSurfaceProps
         @return       true if SkSurfaceProps was copied
 
+        DEPRECATED: Replace usage with getBaseProps() or getTopProps()
+
         example: https://fiddle.skia.org/c/@Canvas_getProps
     */
     bool getProps(SkSurfaceProps* props) const;
 
+    /** Returns the SkSurfaceProps associated with the canvas (i.e., at the base of the layer
+        stack).
+
+        @return  base SkSurfaceProps
+    */
+    SkSurfaceProps getBaseProps() const;
+
+    /** Returns the SkSurfaceProps associated with the canvas that are currently active (i.e., at
+        the top of the layer stack). This can differ from getBaseProps depending on the flags
+        passed to saveLayer (see SaveLayerFlagsSet).
+
+        @return  SkSurfaceProps active in the current/top layer
+    */
+    SkSurfaceProps getTopProps() const;
+
     /** Triggers the immediate execution of all pending draw operations.
         If SkCanvas is associated with GPU surface, resolves all pending GPU operations.
         If SkCanvas is associated with raster surface, has no effect; raster draw
@@ -566,14 +591,14 @@ public:
     */
     int save();
 
-    /** Saves SkMatrix and clip, and allocates a SkBitmap for subsequent drawing.
-        Calling restore() discards changes to SkMatrix and clip, and draws the SkBitmap.
+    /** Saves SkMatrix and clip, and allocates a SkSurface for subsequent drawing.
+        Calling restore() discards changes to SkMatrix and clip, and draws the SkSurface.
 
         SkMatrix may be changed by translate(), scale(), rotate(), skew(), concat(),
         setMatrix(), and resetMatrix(). Clip may be changed by clipRect(), clipRRect(),
         clipPath(), clipRegion().
 
-        SkRect bounds suggests but does not define the SkBitmap size. To clip drawing to
+        SkRect bounds suggests but does not define the SkSurface size. To clip drawing to
         a specific rectangle, use clipRect().
 
         Optional SkPaint paint applies alpha, SkColorFilter, SkImageFilter, and
@@ -590,8 +615,8 @@ public:
     */
     int saveLayer(const SkRect* bounds, const SkPaint* paint);
 
-    /** Saves SkMatrix and clip, and allocates a SkBitmap for subsequent drawing.
-        Calling restore() discards changes to SkMatrix and clip, and draws the SkBitmap.
+    /** Saves SkMatrix and clip, and allocates a SkSurface for subsequent drawing.
+        Calling restore() discards changes to SkMatrix and clip, and draws the SkSurface.
 
         SkMatrix may be changed by translate(), scale(), rotate(), skew(), concat(),
         setMatrix(), and resetMatrix(). Clip may be changed by clipRect(), clipRRect(),
@@ -613,7 +638,7 @@ public:
         return this->saveLayer(&bounds, paint);
     }
 
-    /** Saves SkMatrix and clip, and allocates SkBitmap for subsequent drawing.
+    /** Saves SkMatrix and clip, and allocates SkSurface for subsequent drawing.
 
         Calling restore() discards changes to SkMatrix and clip,
         and blends layer with alpha opacity onto prior layer.
@@ -721,10 +746,10 @@ public:
         SkScalar             fExperimentalBackdropScale = 1.f;
     };
 
-    /** Saves SkMatrix and clip, and allocates SkBitmap for subsequent drawing.
+    /** Saves SkMatrix and clip, and allocates SkSurface for subsequent drawing.
 
         Calling restore() discards changes to SkMatrix and clip,
-        and blends SkBitmap with alpha opacity onto the prior layer.
+        and blends SkSurface with alpha opacity onto the prior layer.
 
         SkMatrix may be changed by translate(), scale(), rotate(), skew(), concat(),
         setMatrix(), and resetMatrix(). Clip may be changed by clipRect(), clipRRect(),
@@ -1956,7 +1981,7 @@ public:
     */
     void drawVertices(const sk_sp<SkVertices>& vertices, SkBlendMode mode, const SkPaint& paint);
 
-#if defined(SK_ENABLE_EXPERIMENTAL_CUSTOM_MESH) && defined(SK_ENABLE_SKSL)
+#if defined(SK_ENABLE_SKSL)
     /**
         Experimental, under active development, and subject to change without notice.
 
@@ -2171,7 +2196,7 @@ protected:
     virtual bool onPeekPixels(SkPixmap* pixmap);
     virtual bool onAccessTopLayerPixels(SkPixmap* pixmap);
     virtual SkImageInfo onImageInfo() const;
-    virtual bool onGetProps(SkSurfaceProps* props) const;
+    virtual bool onGetProps(SkSurfaceProps* props, bool top) const;
     virtual void onFlush();
 
     // Subclass save/restore notifiers.
@@ -2198,11 +2223,6 @@ protected:
     virtual void didTranslate(SkScalar, SkScalar) {}
     virtual void didScale(SkScalar, SkScalar) {}
 
-#ifndef SK_ENABLE_EXPERIMENTAL_CUSTOM_MESH
-    // Define this in protected so we can still access internally for testing.
-    void drawMesh(const SkMesh& mesh, sk_sp<SkBlender> blender, const SkPaint& paint);
-#endif
-
     // NOTE: If you are adding a new onDraw virtual to SkCanvas, PLEASE add an override to
     // SkCanvasVirtualEnforcer (in SkCanvasVirtualEnforcer.h). This ensures that subclasses using
     // that mechanism  will be required to implement the new function.
@@ -2220,7 +2240,7 @@ protected:
     virtual void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                                 const SkPaint& paint);
 
-    virtual void onDrawGlyphRunList(const SkGlyphRunList& glyphRunList, const SkPaint& paint);
+    virtual void onDrawGlyphRunList(const sktext::GlyphRunList& glyphRunList, const SkPaint& paint);
 
     virtual void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
                            const SkPoint texCoords[4], SkBlendMode mode, const SkPaint& paint);
@@ -2270,15 +2290,15 @@ protected:
 
     virtual void onDiscard();
 
-#if SK_SUPPORT_GPU
+#if (SK_SUPPORT_GPU || defined(SK_GRAPHITE_ENABLED))
     /** Experimental
      */
-    virtual sk_sp<GrSlug> onConvertGlyphRunListToSlug(
-            const SkGlyphRunList& glyphRunList, const SkPaint& paint);
+    virtual sk_sp<sktext::gpu::Slug> onConvertGlyphRunListToSlug(
+            const sktext::GlyphRunList& glyphRunList, const SkPaint& paint);
 
     /** Experimental
      */
-    virtual void onDrawSlug(const GrSlug* slug);
+    virtual void onDrawSlug(const sktext::gpu::Slug* slug);
 #endif
 
 private:
@@ -2413,24 +2433,25 @@ protected:
     SkCanvas(const SkIRect& bounds);
 private:
     SkCanvas(const SkBitmap&, std::unique_ptr<SkRasterHandleAllocator>,
-             SkRasterHandleAllocator::Handle);
+             SkRasterHandleAllocator::Handle, const SkSurfaceProps* props);
 
     SkCanvas(SkCanvas&&) = delete;
     SkCanvas(const SkCanvas&) = delete;
     SkCanvas& operator=(SkCanvas&&) = delete;
     SkCanvas& operator=(const SkCanvas&) = delete;
 
-#if SK_SUPPORT_GPU
-    friend class GrSlug;
+#if (SK_SUPPORT_GPU || defined(SK_GRAPHITE_ENABLED))
+    friend class sktext::gpu::Slug;
     /** Experimental
-     * Convert a SkTextBlob to a GrSlug using the current canvas state.
+     * Convert a SkTextBlob to a sktext::gpu::Slug using the current canvas state.
      */
-    sk_sp<GrSlug> convertBlobToSlug(const SkTextBlob& blob, SkPoint origin, const SkPaint& paint);
+    sk_sp<sktext::gpu::Slug> convertBlobToSlug(const SkTextBlob& blob, SkPoint origin,
+                                               const SkPaint& paint);
 
     /** Experimental
-     * Draw an GrSlug given the current canvas state.
+     * Draw an sktext::gpu::Slug given the current canvas state.
      */
-    void drawSlug(const GrSlug* slug);
+    void drawSlug(const sktext::gpu::Slug* slug);
 #endif
 
     /** Experimental
@@ -2534,7 +2555,7 @@ private:
     class AutoUpdateQRBounds;
     void validateClip() const;
 
-    std::unique_ptr<SkGlyphRunBuilder> fScratchGlyphRunBuilder;
+    std::unique_ptr<sktext::GlyphRunBuilder> fScratchGlyphRunBuilder;
 
     using INHERITED = SkRefCnt;
 };

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

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkCapabilities_DEFINED
+#define SkCapabilities_DEFINED
+
+#include "include/core/SkRefCnt.h"
+
+#ifdef SK_ENABLE_SKSL
+#include "include/sksl/SkSLVersion.h"
+namespace SkSL { struct ShaderCaps; }
+#endif
+
+#if defined(SK_GRAPHITE_ENABLED)
+namespace skgpu::graphite { class Caps; }
+#endif
+
+class SK_API SkCapabilities : public SkRefCnt {
+public:
+    static sk_sp<const SkCapabilities> RasterBackend();
+
+#ifdef SK_ENABLE_SKSL
+    SkSL::Version skslVersion() const { return fSkSLVersion; }
+#endif
+
+protected:
+#if defined(SK_GRAPHITE_ENABLED)
+    friend class skgpu::graphite::Caps; // for ctor
+#endif
+
+    SkCapabilities() = default;
+
+#ifdef SK_ENABLE_SKSL
+    void initSkCaps(const SkSL::ShaderCaps*);
+
+    SkSL::Version fSkSLVersion = SkSL::Version::k100;
+#endif
+};
+
+#endif

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

@@ -405,6 +405,11 @@ struct SkRGBA4f {
     uint32_t toBytes_RGBA() const;
     static SkRGBA4f FromBytes_RGBA(uint32_t color);
 
+    /**
+      Returns a copy of the SkRGBA4f but with alpha component set to 1.0f.
+
+      @return         opaque color
+    */
     SkRGBA4f makeOpaque() const {
         return { fR, fG, fB, 1.0f };
     }
@@ -420,6 +425,8 @@ using SkColor4f = SkRGBA4f<kUnpremul_SkAlphaType>;
 
 template <> SK_API SkColor4f SkColor4f::FromColor(SkColor);
 template <> SK_API SkColor   SkColor4f::toSkColor() const;
+template <> SK_API uint32_t  SkColor4f::toBytes_RGBA() const;
+template <> SK_API SkColor4f SkColor4f::FromBytes_RGBA(uint32_t color);
 
 namespace SkColors {
 constexpr SkColor4f kTransparent = {0, 0, 0, 0};

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

@@ -71,7 +71,12 @@ public:
     static sk_sp<SkColorFilter> Compose(sk_sp<SkColorFilter> outer, sk_sp<SkColorFilter> inner) {
         return outer ? outer->makeComposed(inner) : inner;
     }
+
+    // Blends between the constant color (src) and input color (dst) based on the SkBlendMode.
+    // If the color space is null, the constant color is assumed to be defined in sRGB.
+    static sk_sp<SkColorFilter> Blend(const SkColor4f& c, sk_sp<SkColorSpace>, SkBlendMode mode);
     static sk_sp<SkColorFilter> Blend(SkColor c, SkBlendMode mode);
+
     static sk_sp<SkColorFilter> Matrix(const SkColorMatrix&);
     static sk_sp<SkColorFilter> Matrix(const float rowMajor[20]);
 
@@ -84,6 +89,38 @@ public:
     static sk_sp<SkColorFilter> SRGBToLinearGamma();
     static sk_sp<SkColorFilter> Lerp(float t, sk_sp<SkColorFilter> dst, sk_sp<SkColorFilter> src);
 
+    /**
+     *  Create a table colorfilter, copying the table into the filter, and
+     *  applying it to all 4 components.
+     *      a' = table[a];
+     *      r' = table[r];
+     *      g' = table[g];
+     *      b' = table[b];
+     *  Components are operated on in unpremultiplied space. If the incomming
+     *  colors are premultiplied, they are temporarily unpremultiplied, then
+     *  the table is applied, and then the result is remultiplied.
+     */
+    static sk_sp<SkColorFilter> Table(const uint8_t table[256]);
+
+    /**
+     *  Create a table colorfilter, with a different table for each
+     *  component [A, R, G, B]. If a given table is NULL, then it is
+     *  treated as identity, with the component left unchanged. If a table
+     *  is not null, then its contents are copied into the filter.
+     */
+    static sk_sp<SkColorFilter> TableARGB(const uint8_t tableA[256],
+                                          const uint8_t tableR[256],
+                                          const uint8_t tableG[256],
+                                          const uint8_t tableB[256]);
+
+    /**
+     *  Create a colorfilter that multiplies the RGB channels by one color, and
+     *  then adds a second color, pinning the result for each component to
+     *  [0..255]. The alpha components of the mul and add arguments
+     *  are ignored.
+     */
+    static sk_sp<SkColorFilter> Lighting(SkColor mul, SkColor add);
+
 private:
     SkColorFilters() = delete;
 };

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

@@ -11,7 +11,7 @@
 #include "include/core/SkRefCnt.h"
 #include "include/private/SkFixed.h"
 #include "include/private/SkOnce.h"
-#include "include/third_party/skcms/skcms.h"
+#include "modules/skcms/skcms.h"
 #include <memory>
 
 class SkData;

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

@@ -498,6 +498,8 @@ public:
      */
     void dump() const;
 
+    using sk_is_trivially_relocatable = std::true_type;
+
 private:
     enum PrivFlags {
         kForceAutoHinting_PrivFlag      = 1 << 0,
@@ -523,6 +525,8 @@ private:
     uint8_t     fEdging;
     uint8_t     fHinting;
 
+    static_assert(::sk_is_trivially_relocatable<decltype(fTypeface)>::value);
+
     SkScalar setupForAsPaths(SkPaint*);
     bool hasSomeAntiAliasing() const;
 

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

@@ -117,6 +117,9 @@ public:
     /** Return the default fontmgr. */
     static sk_sp<SkFontMgr> RefDefault();
 
+    /* Returns an empty font manager without any typeface dependencies */
+    static sk_sp<SkFontMgr> RefEmpty();
+
 protected:
     virtual int onCountFamilies() const = 0;
     virtual void onGetFamilyName(int index, SkString* familyName) const = 0;

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

@@ -150,6 +150,15 @@ public:
     static OpenTypeSVGDecoderFactory SetOpenTypeSVGDecoderFactory(OpenTypeSVGDecoderFactory);
     static OpenTypeSVGDecoderFactory GetOpenTypeSVGDecoderFactory();
 
+    /**
+     *  Temporarily (until variable COLRv1 is released) pass a feature switch function for whether
+     *  variable COLRv1 is enabled. Needed for initializing FreeType with a property setting so that
+     *  variable COLRv1 can be enabled in Chrome Canaries during development.
+     */
+    using VariableColrV1EnabledFunc = bool (*)();
+    static VariableColrV1EnabledFunc SetVariableColrV1EnabledFunc(VariableColrV1EnabledFunc);
+    static bool GetVariableColrV1Enabled();
+
     /**
      *  Call early in main() to allow Skia to use a JIT to accelerate CPU-bound operations.
      */

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

@@ -13,11 +13,12 @@
 #include "include/core/SkSamplingOptions.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkShader.h"
+#include "include/core/SkSurfaceProps.h"
 #include "include/core/SkTileMode.h"
 #if SK_SUPPORT_GPU
 #include "include/gpu/GrTypes.h"
 #endif
-#if SK_GRAPHITE_ENABLED
+#if defined(SK_GRAPHITE_ENABLED)
 #include "include/gpu/graphite/GraphiteTypes.h"
 #endif
 #include <functional>  // std::function
@@ -49,8 +50,9 @@ class SkYUVAPixmaps;
 
 enum class SkEncodedImageFormat;
 
-#if SK_GRAPHITE_ENABLED
+#if defined(SK_GRAPHITE_ENABLED)
 namespace skgpu::graphite {
+class BackendTexture;
 class Recorder;
 };
 #endif
@@ -253,12 +255,13 @@ public:
         @param paint       SkPaint to apply transparency, filtering, and so on; may be nullptr
         @param bitDepth    8-bit integer or 16-bit float: per component
         @param colorSpace  range of colors; may be nullptr
+        @param props       props to use when rasterizing the picture
         @return            created SkImage, or nullptr
     */
     static sk_sp<SkImage> MakeFromPicture(sk_sp<SkPicture> picture, const SkISize& dimensions,
                                           const SkMatrix* matrix, const SkPaint* paint,
-                                          BitDepth bitDepth,
-                                          sk_sp<SkColorSpace> colorSpace);
+                                          BitDepth bitDepth, sk_sp<SkColorSpace> colorSpace,
+                                          SkSurfaceProps props = {});
 
 #if SK_SUPPORT_GPU
         /** Creates a GPU-backed SkImage from compressed data.
@@ -942,6 +945,36 @@ public:
         kRepeatedCubic,
     };
 
+    /** Makes image pixel data available to caller, possibly asynchronously.
+
+        Currently asynchronous reads are only supported on the GPU backend and only when the
+        underlying 3D API supports transfer buffers and CPU/GPU synchronization primitives. In all
+        other cases this operates synchronously.
+
+        Data is read from the source sub-rectangle, then converted to the color space, color type,
+        and alpha type of 'info'. A 'srcRect' that is not contained by the bounds of the image
+        causes failure.
+
+        When the pixel data is ready the caller's ReadPixelsCallback is called with a
+        AsyncReadResult containing pixel data in the requested color type, alpha type, and color
+        space. The AsyncReadResult will have count() == 1. Upon failure the callback is called with
+        nullptr for AsyncReadResult. For a GPU image this flushes work but a submit must occur to
+        guarantee a finite time before the callback is called.
+
+        The data is valid for the lifetime of AsyncReadResult with the exception that if the SkImage
+        is GPU-backed the data is immediately invalidated if the context is abandoned or
+        destroyed.
+
+        @param info            info of the requested pixels
+        @param srcRect         subrectangle of image to read
+        @param callback        function to call with result of the read
+        @param context         passed to callback
+    */
+    void asyncReadPixels(const SkImageInfo& info,
+                         const SkIRect& srcRect,
+                         ReadPixelsCallback callback,
+                         ReadPixelsContext context) const;
+
     /** Makes image pixel data available to caller, possibly asynchronously. It can also rescale
         the image pixels.
 
@@ -1143,30 +1176,57 @@ public:
                                     GrMipmapped = GrMipmapped::kNo,
                                     SkBudgeted = SkBudgeted::kYes) const;
 #endif
+
 #ifdef SK_GRAPHITE_ENABLED
+    /** 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
+    */
+    static sk_sp<SkImage> MakeGraphiteFromBackendTexture(skgpu::graphite::Recorder*,
+                                                         const skgpu::graphite::BackendTexture&,
+                                                         SkColorType colorType,
+                                                         SkAlphaType alphaType,
+                                                         sk_sp<SkColorSpace> colorSpace);
+
+    struct RequiredImageProperties {
+        skgpu::graphite::Mipmapped fMipmapped;
+    };
+
     /** Graphite version of makeTextureImage.
 
-        Returns SkImage backed by GPU texture, using Recorder for creation and uploads if necessary.
-        The returned SkImage respects mipmapped setting for non-GPU SkImages; if mipmapped
-        equals GrMipmapped::kYes, the backing texture allocates mip map levels.
+        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 texture-backed, the recorder matches, and
-        mipmapped is compatible with the backing GPU texture. If mipmapped is not compatible,
-        it will return nullptr.
+        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 recorder is nullptr, or if SkImage was created with another
+        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 Mipmapped       whether created SkImage texture must allocate mip map levels
-        @return                created SkImage, or nullptr
+        @param Recorder                 the Recorder to use for storing commands
+        @param RequiredImageProperties  properties the returned SkImage must possess (e.g.,
+                                        mipmaps)
+        @return                         created SkImage, or nullptr
     */
     sk_sp<SkImage> makeTextureImage(skgpu::graphite::Recorder*,
-                                    skgpu::graphite::Mipmapped = skgpu::graphite::Mipmapped::kNo,
-                                    SkBudgeted = SkBudgeted::kYes) const;
-
+                                    RequiredImageProperties = {}) const;
 #endif
 
     /** Returns raster image or lazy image. Copies SkImage backed by GPU texture into

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

@@ -8,12 +8,14 @@
 #ifndef SkImageEncoder_DEFINED
 #define SkImageEncoder_DEFINED
 
-#include "include/core/SkData.h"
 #include "include/core/SkEncodedImageFormat.h"
-#include "include/core/SkPixmap.h"
-#include "include/core/SkStream.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
 
 class SkBitmap;
+class SkData;
+class SkPixmap;
+class SkWStream;
 
 /**
  * Encode SkPixmap in the given binary image format.