@shopify/react-native-skia 0.1.196 → 0.1.199

package/cpp/skia/include/effects/SkRuntimeEffect.h

@@ -8,11 +8,12 @@
 #ifndef SkRuntimeEffect_DEFINED
 #define SkRuntimeEffect_DEFINED
 
-#include "include/core/SkBlender.h"
-#include "include/core/SkColorFilter.h"
+#include "include/core/SkBlender.h"  // IWYU pragma: keep
+#include "include/core/SkColorFilter.h"  // IWYU pragma: keep
 #include "include/core/SkData.h"
-#include "include/core/SkImageInfo.h"
+#include "include/core/SkFlattenable.h"
 #include "include/core/SkMatrix.h"
+#include "include/core/SkRefCnt.h"
 #include "include/core/SkShader.h"
 #include "include/core/SkSpan.h"
 #include "include/core/SkString.h"
@@ -20,34 +21,38 @@
 #include "include/private/SkSLSampleUsage.h"
 #include "include/private/base/SkOnce.h"
 #include "include/private/base/SkTemplates.h"
+#include "include/private/base/SkTo.h"
+#include "include/private/base/SkTypeTraits.h"
 
-#include <string>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory>
 #include <optional>
+#include <string>
+#include <string_view>
+#include <utility>
 #include <vector>
 
 #ifdef SK_ENABLE_SKSL
 
+#include "include/sksl/SkSLDebugTrace.h"
 #include "include/sksl/SkSLVersion.h"
 
 class GrRecordingContext;
 class SkFilterColorProgram;
 class SkImage;
-class SkRuntimeImageFilter;
+struct SkIPoint;
+struct SkImageInfo;
 
 namespace SkSL {
-class DebugTrace;
 class DebugTracePriv;
-class ErrorReporter;
 class FunctionDefinition;
 struct Program;
 enum class ProgramKind : int8_t;
 struct ProgramSettings;
 }  // namespace SkSL
 
-namespace skvm {
-class Program;
-}
-
 namespace SkSL::RP {
 class Program;
 }
@@ -319,7 +324,7 @@ private:
     friend class GrGLSLSkSLFP;         //
 #endif
 
-    friend class SkRTShader;            // fBaseProgram, fMain, fSampleUsages, getRPProgram()
+    friend class SkRuntimeShader;       // fBaseProgram, fMain, fSampleUsages, getRPProgram()
     friend class SkRuntimeBlender;      //
     friend class SkRuntimeColorFilter;  //
 

package/cpp/skia/include/gpu/GrBackendSurface.h

@@ -8,36 +8,38 @@
 #ifndef GrBackendSurface_DEFINED
 #define GrBackendSurface_DEFINED
 
-// This include of GrBackendSurfaceMutableState is not needed here, but some clients were depending
-// on the include here instead of including it themselves. Adding this back here until we can fix
-// up clients so it can be removed.
-#include "include/gpu/GrBackendSurfaceMutableState.h"
-
-#include "include/gpu/GrSurfaceInfo.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSize.h"
+#include "include/gpu/GpuTypes.h"
 #include "include/gpu/GrTypes.h"
-#include "include/gpu/MutableTextureState.h"
+#include "include/private/base/SkAPI.h"
+#include "include/private/gpu/ganesh/GrTypesPriv.h"
+
 #ifdef SK_GL
 #include "include/gpu/gl/GrGLTypes.h"
 #include "include/private/gpu/ganesh/GrGLTypesPriv.h"
 #endif
+
 #include "include/gpu/mock/GrMockTypes.h"
+
 #ifdef SK_VULKAN
 #include "include/gpu/vk/GrVkTypes.h"
 #include "include/private/gpu/ganesh/GrVkTypesPriv.h"
+#include "include/private/gpu/vk/SkiaVulkan.h"
 #endif
 
 #ifdef SK_DAWN
 #include "include/gpu/dawn/GrDawnTypes.h"
 #endif
 
+#include <cstdint>
 #include <string>
+#include <string_view>
 
-class GrVkImageLayout;
-class GrGLTextureParameters;
-class GrColorFormatDesc;
 enum class SkTextureCompressionType;
 
 namespace skgpu {
+class MutableTextureState;
 class MutableTextureStateRef;
 }
 
@@ -58,33 +60,6 @@ class GrD3DResourceState;
 class SkString;
 #endif
 
-#if !defined(SK_GANESH)
-
-// SkSurfaceCharacterization always needs a minimal version of this
-class SK_API GrBackendFormat {
-public:
-    bool isValid() const { return false; }
-};
-
-// SkSurface and SkImage rely on a minimal version of these always being available
-class SK_API GrBackendTexture {
-public:
-    GrBackendTexture() {}
-
-    bool isValid() const { return false; }
-};
-
-class SK_API GrBackendRenderTarget {
-public:
-    GrBackendRenderTarget() {}
-
-    bool isValid() const { return false; }
-    bool isFramebufferOnly() const { return false; }
-};
-#else
-
-enum class GrGLFormat;
-
 class SK_API GrBackendFormat {
 public:
     // Creates an invalid backend format.
@@ -663,5 +638,3 @@ private:
 };
 
 #endif
-
-#endif

package/cpp/skia/include/gpu/GrBackendSurfaceMutableState.h

@@ -10,6 +10,12 @@
 
 #include "include/gpu/MutableTextureState.h"
 
+#ifdef SK_VULKAN
+#include "include/private/gpu/vk/SkiaVulkan.h"
+
+#include <cstdint>
+#endif
+
 class GrBackendSurfaceMutableState : public skgpu::MutableTextureState {
 public:
     GrBackendSurfaceMutableState() = default;

package/cpp/skia/include/gpu/GrContextThreadSafeProxy.h

@@ -22,9 +22,9 @@
 class GrBackendFormat;
 class GrCaps;
 class GrContextThreadSafeProxyPriv;
+class GrSurfaceCharacterization;
 class GrThreadSafeCache;
 class GrThreadSafePipelineBuilder;
-class SkSurfaceCharacterization;
 class SkSurfaceProps;
 enum class SkTextureCompressionType;
 
@@ -85,7 +85,7 @@ public:
      *                                         willUseGLFBO0 = false
      *                                         vkRTSupportsInputAttachment = false
      */
-    SkSurfaceCharacterization createCharacterization(
+    GrSurfaceCharacterization createCharacterization(
                                   size_t cacheMaxResourceBytes,
                                   const SkImageInfo& ii,
                                   const GrBackendFormat& backendFormat,
@@ -102,7 +102,7 @@ public:
     /*
      * Retrieve the default GrBackendFormat for a given SkColorType and renderability.
      * It is guaranteed that this backend format will be the one used by the following
-     * SkColorType and SkSurfaceCharacterization-based createBackendTexture methods.
+     * SkColorType and GrSurfaceCharacterization-based createBackendTexture methods.
      *
      * The caller should check that the returned format is valid.
      */

package/cpp/skia/include/gpu/GrDirectContext.h

@@ -36,6 +36,7 @@ class GrResourceProvider;
 class SkData;
 class SkImage;
 class SkPixmap;
+class SkSurface;
 class SkTaskGroup;
 class SkTraceMemoryDump;
 enum SkColorType : int;
@@ -55,6 +56,10 @@ namespace skgpu {
 namespace sktext { namespace gpu { class StrikeCache; } }
 namespace wgpu { class Device; } // IWYU pragma: keep
 
+namespace SkSurfaces {
+enum class BackendSurfaceAccess;
+}
+
 class SK_API GrDirectContext : public GrRecordingContext {
 public:
 #ifdef SK_GL
@@ -408,10 +413,105 @@ public:
     void flush(sk_sp<const SkImage> image);
 
     /** Version of flush() that uses a default GrFlushInfo. Also submits the flushed work to the
-        GPU.
-    */
+     *   GPU.
+     */
     void flushAndSubmit(sk_sp<const SkImage> image);
 
+    /** Issues pending SkSurface commands to the GPU-backed API objects and resolves any SkSurface
+     *  MSAA. A call to GrDirectContext::submit is always required to ensure work is actually sent
+     *  to the gpu. Some specific API details:
+     *      GL: Commands are actually sent to the driver, but glFlush is never called. Thus some
+     *          sync objects from the flush will not be valid until a submission occurs.
+     *
+     *      Vulkan/Metal/D3D/Dawn: Commands are recorded to the backend APIs corresponding command
+     *          buffer or encoder objects. However, these objects are not sent to the gpu until a
+     *          submission occurs.
+     *
+     *  The work that is submitted to the GPU will be dependent on the BackendSurfaceAccess that is
+     *  passed in.
+     *
+     *  If BackendSurfaceAccess::kNoAccess is passed in all commands will be issued to the GPU.
+     *
+     *  If BackendSurfaceAccess::kPresent is passed in and the backend API is not Vulkan, it is
+     *  treated the same as kNoAccess. If the backend API is Vulkan, the VkImage that backs the
+     *  SkSurface will be transferred back to its original queue. If the SkSurface was created by
+     *  wrapping a VkImage, the queue will be set to the queue which was originally passed in on
+     *  the GrVkImageInfo. Additionally, if the original queue was not external or foreign the
+     *  layout of the VkImage will be set to VK_IMAGE_LAYOUT_PRESENT_SRC_KHR.
+     *
+     *  The GrFlushInfo describes additional options to flush. Please see documentation at
+     *  GrFlushInfo for more info.
+     *
+     *  If the return is GrSemaphoresSubmitted::kYes, only initialized GrBackendSemaphores will be
+     *  submitted to the gpu during the next submit call (it is possible Skia failed to create a
+     *  subset of the semaphores). The client should not wait on these semaphores until after submit
+     *  has been called, but must keep them alive until then. If a submit flag was passed in with
+     *  the flush these valid semaphores can we waited on immediately. If this call returns
+     *  GrSemaphoresSubmitted::kNo, the GPU backend will not submit any semaphores to be signaled on
+     *  the GPU. Thus the client should not have the GPU wait on any of the semaphores passed in
+     *  with the GrFlushInfo. Regardless of whether semaphores were submitted to the GPU or not, the
+     *  client is still responsible for deleting any initialized semaphores.
+     *  Regardless of semaphore submission the context will still be flushed. It should be
+     *  emphasized that a return value of GrSemaphoresSubmitted::kNo does not mean the flush did not
+     *  happen. It simply means there were no semaphores submitted to the GPU. A caller should only
+     *  take this as a failure if they passed in semaphores to be submitted.
+     *
+     *  Pending surface commands are flushed regardless of the return result.
+     *
+     *  @param surface  The GPU backed surface to be flushed. Has no effect on a CPU-backed surface.
+     *  @param access  type of access the call will do on the backend object after flush
+     *  @param info    flush options
+     */
+    GrSemaphoresSubmitted flush(sk_sp<SkSurface> surface,
+                                SkSurfaces::BackendSurfaceAccess access,
+                                const GrFlushInfo& info);
+    GrSemaphoresSubmitted flush(SkSurface* surface,
+                                SkSurfaces::BackendSurfaceAccess access,
+                                const GrFlushInfo& info);
+
+    /**
+     *  Same as above except:
+     *
+     *  If a skgpu::MutableTextureState is passed in, at the end of the flush we will transition
+     *  the surface to be in the state requested by the skgpu::MutableTextureState. If the surface
+     *  (or SkImage or GrBackendSurface wrapping the same backend object) is used again after this
+     *  flush the state may be changed and no longer match what is requested here. This is often
+     *  used if the surface will be used for presenting or external use and the client wants backend
+     *  object to be prepped for that use. A finishedProc or semaphore on the GrFlushInfo will also
+     *  include the work for any requested state change.
+     *
+     *  If the backend API is Vulkan, the caller can set the skgpu::MutableTextureState's
+     *  VkImageLayout to VK_IMAGE_LAYOUT_UNDEFINED or queueFamilyIndex to VK_QUEUE_FAMILY_IGNORED to
+     *  tell Skia to not change those respective states.
+     *
+     *  @param surface  The GPU backed surface to be flushed. Has no effect on a CPU-backed surface.
+     *  @param info     flush options
+     *  @param newState optional state change request after flush
+     */
+    GrSemaphoresSubmitted flush(sk_sp<SkSurface> surface,
+                                const GrFlushInfo& info,
+                                const skgpu::MutableTextureState* newState = nullptr);
+    GrSemaphoresSubmitted flush(SkSurface* surface,
+                                const GrFlushInfo& info,
+                                const skgpu::MutableTextureState* newState = nullptr);
+
+    /** Call to ensure all reads/writes of the surface have been issued to the underlying 3D API.
+     *  Skia will correctly order its own draws and pixel operations. This must to be used to ensure
+     *  correct ordering when the surface backing store is accessed outside Skia (e.g. direct use of
+     *  the 3D API or a windowing system). This is equivalent to
+     *  calling ::flush with a default GrFlushInfo followed by ::submit(syncCpu).
+     *
+     *  Has no effect on a CPU-backed surface.
+     */
+    void flushAndSubmit(sk_sp<SkSurface> surface, bool syncCpu = false);
+
+    /**
+     * Flushes the given surface with the default GrFlushInfo.
+     *
+     *  Has no effect on a CPU-backed surface.
+     */
+    void flush(sk_sp<SkSurface> surface);
+
     /**
      * Submit outstanding work to the gpu from all previously un-submitted flushes. The return
      * value of the submit will indicate whether or not the submission to the GPU was successful.
@@ -444,7 +544,7 @@ public:
     /**
      * Retrieve the default GrBackendFormat for a given SkColorType and renderability.
      * It is guaranteed that this backend format will be the one used by the following
-     * SkColorType and SkSurfaceCharacterization-based createBackendTexture methods.
+     * SkColorType and GrSurfaceCharacterization-based createBackendTexture methods.
      *
      * The caller should check that the returned format is valid.
      */

package/cpp/skia/include/gpu/GrRecordingContext.h

@@ -8,26 +8,27 @@
 #ifndef GrRecordingContext_DEFINED
 #define GrRecordingContext_DEFINED
 
+#include "include/core/SkColorType.h"
 #include "include/core/SkRefCnt.h"
+#include "include/core/SkString.h" // IWYU pragma: keep
 #include "include/core/SkTypes.h"
 #include "include/private/base/SkTArray.h"
+#include "include/private/gpu/ganesh/GrContext_Base.h"
 #include "include/private/gpu/ganesh/GrImageContext.h"
 
-#if GR_GPU_STATS && GR_TEST_UTILS
 #include <map>
+#include <memory>
 #include <string>
-#endif
 
 class GrAuditTrail;
-class GrBackendFormat;
+class GrContextThreadSafeProxy;
+class GrDirectContext;
 class GrDrawingManager;
 class GrOnFlushCallbackObject;
-class GrMemoryPool;
 class GrProgramDesc;
 class GrProgramInfo;
 class GrProxyProvider;
 class GrRecordingContextPriv;
-class GrSurfaceProxy;
 class GrThreadSafeCache;
 class SkArenaAlloc;
 class SkCapabilities;
@@ -38,25 +39,17 @@ class SubRunAllocator;
 class TextBlobRedrawCoordinator;
 }
 
-#if GR_TEST_UTILS
-class SkString;
-#endif
-
 class GrRecordingContext : public GrImageContext {
 public:
     ~GrRecordingContext() override;
 
-    SK_API GrBackendFormat defaultBackendFormat(SkColorType ct, GrRenderable renderable) const {
-        return INHERITED::defaultBackendFormat(ct, renderable);
-    }
-
     /**
      * Reports whether the GrDirectContext associated with this GrRecordingContext is abandoned.
      * When called on a GrDirectContext it may actively check whether the underlying 3D API
      * device/context has been disconnected before reporting the status. If so, calling this
      * method will transition the GrDirectContext to the abandoned state.
      */
-    bool abandoned() override { return INHERITED::abandoned(); }
+    bool abandoned() override { return GrImageContext::abandoned(); }
 
     /*
      * Can a SkSurface be created with the given color type. To check whether MSAA is supported
@@ -96,7 +89,7 @@ public:
      * is not supported at all.
      */
     SK_API int maxSurfaceSampleCountForColorType(SkColorType colorType) const {
-        return INHERITED::maxSurfaceSampleCountForColorType(colorType);
+        return GrImageContext::maxSurfaceSampleCountForColorType(colorType);
     }
 
     SK_API sk_sp<const SkCapabilities> skCapabilities() const;
@@ -126,8 +119,8 @@ public:
 
 protected:
     friend class GrRecordingContextPriv;    // for hidden functions
-    friend class SkDeferredDisplayList;     // for OwnedArenas
-    friend class SkDeferredDisplayListPriv; // for ProgramData
+    friend class GrDeferredDisplayList;     // for OwnedArenas
+    friend class GrDeferredDisplayListPriv; // for ProgramData
 
     // Like Arenas, but preserves ownership of the underlying pools.
     class OwnedArenas {
@@ -275,8 +268,6 @@ private:
 #if GR_TEST_UTILS
     int fSuppressWarningMessages = 0;
 #endif
-
-    using INHERITED = GrImageContext;
 };
 
 /**

package/cpp/skia/include/gpu/MutableTextureState.h

@@ -8,10 +8,14 @@
 #ifndef skgpu_MutableTextureState_DEFINED
 #define skgpu_MutableTextureState_DEFINED
 
+#include "include/core/SkTypes.h"
 #include "include/gpu/GpuTypes.h"
 
 #ifdef SK_VULKAN
+#include "include/private/gpu/vk/SkiaVulkan.h"
 #include "include/private/gpu/vk/VulkanTypesPriv.h"
+
+#include <cstdint>
 #endif
 
 #include <new>

package/cpp/skia/include/gpu/ganesh/GrExternalTextureGenerator.h

@@ -0,0 +1,54 @@
+/*
+ * 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 GrExternalTextureGenerator_DEFINED
+#define GrExternalTextureGenerator_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/GrBackendSurface.h"
+#include "include/private/base/SkAPI.h"
+#include "include/private/gpu/ganesh/GrTextureGenerator.h"
+
+#include <memory>
+
+class GrRecordingContext;
+class GrSurfaceProxyView;
+class SkImage;
+enum class GrImageTexGenPolicy : int;
+namespace skgpu { enum class Mipmapped : bool; }
+struct SkImageInfo;
+
+class GrExternalTexture {
+public:
+    virtual ~GrExternalTexture() = default;
+    virtual GrBackendTexture getBackendTexture() = 0;
+    virtual void dispose() = 0;
+};
+
+class SK_API GrExternalTextureGenerator : public GrTextureGenerator {
+public:
+    GrExternalTextureGenerator(const SkImageInfo& info);
+
+    GrSurfaceProxyView onGenerateTexture(GrRecordingContext*,
+                                         const SkImageInfo&,
+                                         skgpu::Mipmapped,
+                                         GrImageTexGenPolicy) override;
+    virtual std::unique_ptr<GrExternalTexture> generateExternalTexture(GrRecordingContext *,
+                                                                       skgpu::Mipmapped) = 0;
+};
+
+namespace SkImages {
+/**
+ *   Like SkImages::DeferredFromGenerator except allows for the use of GrTextureGenerator.
+ *
+ *   @param gen producer of textures
+ *   @return    created SkImage, or nullptr
+ */
+SK_API sk_sp<SkImage> DeferredFromTextureGenerator(std::unique_ptr<GrTextureGenerator> gen);
+}
+
+#endif  // GrExternalTextureGenerator_DEFINED

package/cpp/skia/include/gpu/ganesh/SkImageGanesh.h

@@ -14,25 +14,24 @@
 #include "include/gpu/GrTypes.h"
 #include "include/private/base/SkAPI.h"
 
+// TODO(kjlubick) remove after chromium is migrated to include this directly
+#include "include/private/chromium/SkImageChromium.h"  // IWYU pragma: keep
+
 #include <functional>
 #include <utility>
 
-class GrBackendFormat;
 class GrBackendTexture;
-class GrContextThreadSafeProxy;
 class GrDirectContext;
 class GrRecordingContext;
-class GrYUVABackendTextureInfo;
 class GrYUVABackendTextures;
 class SkColorSpace;
 class SkData;
 class SkPixmap;
-class SkPromiseImageTexture;
 class SkYUVAPixmaps;
 enum SkAlphaType : int;
 enum SkColorType : int;
 enum class SkTextureCompressionType;
-struct SkISize;
+struct SkIRect;
 
 /**
  * All factories in this file refer to the Ganesh GPU backend when they say GPU.
@@ -262,77 +261,6 @@ SK_API sk_sp<SkImage> TextureFromYUVATextures(GrRecordingContext* context,
 SK_API sk_sp<SkImage> TextureFromYUVATextures(GrRecordingContext* context,
                                               const GrYUVABackendTextures& yuvaTextures);
 
-using PromiseImageTextureContext = void*;
-using PromiseImageTextureFulfillProc = sk_sp<SkPromiseImageTexture> (*)(PromiseImageTextureContext);
-using PromiseImageTextureReleaseProc = void (*)(PromiseImageTextureContext);
-
-/** Create a new GPU-backed SkImage that is very similar to an SkImage created by BorrowTextureFrom.
-    The difference is that the caller need not have created the texture nor populated it with the
-    image pixel data. Moreover, the SkImage may be created on a thread as the creation of the
-    image does not require access to the backend API or GrDirectContext. Instead of passing a
-    GrBackendTexture the client supplies a description of the texture consisting of
-    GrBackendFormat, width, height, and GrMipmapped state. The resulting SkImage can be drawn
-    to a SkDeferredDisplayListRecorder or directly to a GPU-backed SkSurface.
-    When the actual texture is required to perform a backend API draw, textureFulfillProc will
-    be called to receive a GrBackendTexture. The properties of the GrBackendTexture must match
-    those set during the SkImage creation, and it must refer to a valid existing texture in the
-    backend API context/device, and be populated with the image pixel data. The texture cannot
-    be deleted until textureReleaseProc is called.
-    There is at most one call to each of textureFulfillProc and textureReleaseProc.
-    textureReleaseProc is always called even if image creation fails or if the
-    image is never fulfilled (e.g. it is never drawn or all draws are clipped out)
-    @param gpuContextProxy     the thread-safe proxy of the gpu context. required.
-    @param backendFormat       format of promised gpu texture
-    @param dimensions          width & height of promised gpu texture
-    @param mipmapped           mip mapped state of promised gpu texture
-    @param origin              surface origin of promised gpu texture
-    @param colorType           color type of promised gpu texture
-    @param alphaType           alpha type of promised gpu texture
-    @param colorSpace          range of colors; may be nullptr
-    @param textureFulfillProc  function called to get actual gpu texture
-    @param textureReleaseProc  function called when texture can be deleted
-    @param textureContext      state passed to textureFulfillProc and textureReleaseProc
-    @return                    created SkImage, or nullptr
-*/
-SK_API sk_sp<SkImage> PromiseTextureFrom(sk_sp<GrContextThreadSafeProxy> gpuContextProxy,
-                                         const GrBackendFormat& backendFormat,
-                                         SkISize dimensions,
-                                         GrMipmapped mipmapped,
-                                         GrSurfaceOrigin origin,
-                                         SkColorType colorType,
-                                         SkAlphaType alphaType,
-                                         sk_sp<SkColorSpace> colorSpace,
-                                         PromiseImageTextureFulfillProc textureFulfillProc,
-                                         PromiseImageTextureReleaseProc textureReleaseProc,
-                                         PromiseImageTextureContext textureContext);
-
-/** 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,
-    conversion to RGB, and origin of the textures. Separate 'textureFulfillProc' and
-    'textureReleaseProc' calls are made for each texture. Each texture has its own
-    PromiseImageTextureContext. If 'backendTextureInfo' is not valid then no release proc
-    calls are made. Otherwise, the calls will be made even on failure. 'textureContexts' has one
-    entry for each of the up to four textures, as indicated by 'backendTextureInfo'.
-    Currently the mip mapped property of 'backendTextureInfo' is ignored. However, in the
-    near future it will be required that if it is kYes then textureFulfillProc must return
-    a mip mapped texture for each plane in order to successfully draw the image.
-    @param gpuContextProxy     the thread-safe proxy of the gpu context. required.
-    @param backendTextureInfo  info about the promised yuva gpu texture
-    @param imageColorSpace     range of colors; may be nullptr
-    @param textureFulfillProc  function called to get actual gpu texture
-    @param textureReleaseProc  function called when texture can be deleted
-    @param textureContexts     state passed to textureFulfillProc and textureReleaseProc
-    @return                    created SkImage, or nullptr
-*/
-SK_API sk_sp<SkImage> PromiseTextureFromYUVA(sk_sp<GrContextThreadSafeProxy> gpuContextProxy,
-                                             const GrYUVABackendTextureInfo& backendTextureInfo,
-                                             sk_sp<SkColorSpace> imageColorSpace,
-                                             PromiseImageTextureFulfillProc textureFulfillProc,
-                                             PromiseImageTextureReleaseProc textureReleaseProc,
-                                             PromiseImageTextureContext textureContexts[]);
-
 /** Retrieves the existing backend texture. If SkImage is not a Ganesh-backend texture image
     or otherwise does not have such a texture, false is returned. Otherwise, outTexture will
     be set to the image's texture.
@@ -380,6 +308,22 @@ inline bool GetBackendTextureFromImage(GrDirectContext* context,
                                        backendTextureReleaseProc);
 }
 
+/** 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 context the non-null GrDirectContext to which the subset should be uploaded.
+    @param subset  bounds of returned SkImage
+    @return        the subsetted image, uploaded as a texture, or nullptr
+*/
+SK_API sk_sp<SkImage> SubsetTextureFrom(GrDirectContext* context,
+                                        const SkImage* img,
+                                        const SkIRect& subset);
+
 }  // namespace SkImages
 
 #endif