@shopify/react-native-skia 0.1.196 → 0.1.199

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

@@ -45,10 +45,9 @@ public:
     TArray() : fOwnMemory(true), fCapacity{0} {}
 
     /**
-     * Creates an empty array that will preallocate space for reserveCount
-     * elements.
+     * Creates an empty array that will preallocate space for reserveCount elements.
      */
-    explicit TArray(int reserveCount) : TArray() { this->reserve_back(reserveCount); }
+    explicit TArray(int reserveCount) : TArray() { this->reserve_exact(reserveCount); }
 
     /**
      * Copies one array to another. The new array will be heap allocated.
@@ -149,7 +148,9 @@ public:
     }
 
     /**
-     * Ensures there is enough reserved space for n elements.
+     * Ensures there is enough reserved space for at least n elements. This is guaranteed at least
+     * until the array size grows above n and subsequently shrinks below n, any version of reset()
+     * is called, or reserve() is called again.
      */
     void reserve(int n) {
         SkASSERT(n >= 0);
@@ -159,14 +160,13 @@ public:
     }
 
     /**
-     * Ensures there is enough reserved space for n additional elements. The is guaranteed at least
-     * until the array size grows above n and subsequently shrinks below n, any version of reset()
-     * is called, or reserve_back() is called again.
+     * Ensures there is enough reserved space for exactly n elements. The same capacity guarantees
+     * as above apply.
      */
-    void reserve_back(int n) {
+    void reserve_exact(int n) {
         SkASSERT(n >= 0);
-        if (n > 0) {
-            this->checkRealloc(n, kExactFit);
+        if (n > this->size()) {
+            this->checkRealloc(n - this->size(), kExactFit);
         }
     }
 
@@ -652,7 +652,7 @@ public:
         : STArray{data.begin(), SkToInt(data.size())} {}
 
     explicit STArray(int reserveCount)
-        : STArray() { this->reserve_back(reserveCount); }
+        : STArray() { this->reserve_exact(reserveCount); }
 
     STArray(const STArray& that)
         : STArray() { *this = that; }

package/cpp/skia/include/private/chromium/GrDeferredDisplayList.h

@@ -0,0 +1,120 @@
+/*
+ * 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 GrDeferredDisplayList_DEFINED
+#define GrDeferredDisplayList_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+#include "include/gpu/GrRecordingContext.h"
+#include "include/private/base/SkTArray.h"
+#include "include/private/chromium/GrSurfaceCharacterization.h"
+
+class GrDirectContext;
+class GrRenderTargetProxy;
+class GrRenderTask;
+class GrDeferredDisplayListPriv;
+class SkSurface;
+
+/*
+ * This class contains pre-processed gpu operations that can be replayed into
+ * an SkSurface via SkSurface::draw(GrDeferredDisplayList*).
+ */
+class GrDeferredDisplayList : public SkNVRefCnt<GrDeferredDisplayList> {
+public:
+    SK_API ~GrDeferredDisplayList();
+
+    SK_API const GrSurfaceCharacterization& characterization() const {
+        return fCharacterization;
+    }
+    /**
+     * Iterate through the programs required by the DDL.
+     */
+    class SK_API ProgramIterator {
+    public:
+        ProgramIterator(GrDirectContext*, GrDeferredDisplayList*);
+        ~ProgramIterator();
+
+        // This returns true if any work was done. Getting a cache hit does not count as work.
+        bool compile();
+        bool done() const;
+        void next();
+
+    private:
+        GrDirectContext*                                 fDContext;
+        const skia_private::TArray<GrRecordingContext::ProgramData>& fProgramData;
+        int                                              fIndex;
+    };
+
+    // Provides access to functions that aren't part of the public API.
+    GrDeferredDisplayListPriv priv();
+    const GrDeferredDisplayListPriv priv() const;  // NOLINT(readability-const-return-type)
+
+private:
+    friend class GrDrawingManager; // for access to 'fRenderTasks', 'fLazyProxyData', 'fArenas'
+    friend class GrDeferredDisplayListRecorder; // for access to 'fLazyProxyData'
+    friend class GrDeferredDisplayListPriv;
+
+    // This object is the source from which the lazy proxy backing the DDL will pull its backing
+    // texture when the DDL is replayed. It has to be separately ref counted bc the lazy proxy
+    // can outlive the DDL.
+    class LazyProxyData : public SkRefCnt {
+    public:
+        // Upon being replayed - this field will be filled in (by the DrawingManager) with the
+        // proxy backing the destination SkSurface. Note that, since there is no good place to
+        // clear it, it can become a dangling pointer. Additionally, since the renderTargetProxy
+        // doesn't get a ref here, the SkSurface that owns it must remain alive until the DDL
+        // is flushed.
+        // TODO: the drawing manager could ref the renderTargetProxy for the DDL and then add
+        // a renderingTask to unref it after the DDL's ops have been executed.
+        GrRenderTargetProxy* fReplayDest = nullptr;
+    };
+
+    SK_API GrDeferredDisplayList(const GrSurfaceCharacterization& characterization,
+                                 sk_sp<GrRenderTargetProxy> fTargetProxy,
+                                 sk_sp<LazyProxyData>);
+
+    const skia_private::TArray<GrRecordingContext::ProgramData>& programData() const {
+        return fProgramData;
+    }
+
+    const GrSurfaceCharacterization fCharacterization;
+
+    // These are ordered such that the destructor cleans op tasks up first (which may refer back
+    // to the arena and memory pool in their destructors).
+    GrRecordingContext::OwnedArenas fArenas;
+    skia_private::TArray<sk_sp<GrRenderTask>>   fRenderTasks;
+
+    skia_private::TArray<GrRecordingContext::ProgramData> fProgramData;
+    sk_sp<GrRenderTargetProxy>      fTargetProxy;
+    sk_sp<LazyProxyData>            fLazyProxyData;
+};
+
+namespace skgpu::ganesh {
+/** Draws the deferred display list created via a GrDeferredDisplayListRecorder.
+    If the deferred display list is not compatible with the surface, the draw is skipped
+    and false is return.
+
+    The xOffset and yOffset parameters are experimental and, if not both zero, will cause
+    the draw to be ignored.
+    When implemented, if xOffset or yOffset are non-zero, the DDL will be drawn offset by that
+    amount into the surface.
+
+    @param SkSurface            The surface to apply the commands to, cannot be nullptr.
+    @param ddl                  drawing commands, cannot be nullptr.
+    @return                     false if ddl is not compatible
+
+    example: https://fiddle.skia.org/c/@Surface_draw_2
+*/
+SK_API bool DrawDDL(SkSurface*,
+                    sk_sp<const GrDeferredDisplayList> ddl);
+
+SK_API bool DrawDDL(sk_sp<SkSurface>,
+                    sk_sp<const GrDeferredDisplayList> ddl);
+}
+
+#endif

package/cpp/skia/include/private/chromium/GrDeferredDisplayListRecorder.h

@@ -0,0 +1,98 @@
+/*
+ * 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 GrDeferredDisplayListRecorder_DEFINED
+#define GrDeferredDisplayListRecorder_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+#include "include/gpu/GrTypes.h"
+#include "include/private/chromium/GrDeferredDisplayList.h"
+#include "include/private/chromium/GrSurfaceCharacterization.h"
+
+class GrBackendFormat;
+class GrRecordingContext;
+class GrRenderTargetProxy;
+class GrYUVABackendTextureInfo;
+class SkCanvas;
+class SkColorSpace;
+class SkImage;
+class GrPromiseImageTexture;
+class SkSurface;
+enum SkAlphaType : int;
+enum SkColorType : int;
+
+/*
+ * This class is intended to be used as:
+ *   Get a GrSurfaceCharacterization representing the intended gpu-backed destination SkSurface
+ *   Create one of these (a GrDeferredDisplayListRecorder) on the stack
+ *   Get the canvas and render into it
+ *   Snap off and hold on to a GrDeferredDisplayList
+ *   Once your app actually needs the pixels, call skgpu::ganesh::DrawDDL(GrDeferredDisplayList*)
+ *
+ * This class never accesses the GPU but performs all the cpu work it can. It
+ * is thread-safe (i.e., one can break a scene into tiles and perform their cpu-side
+ * work in parallel ahead of time).
+ */
+class SK_API GrDeferredDisplayListRecorder {
+public:
+    GrDeferredDisplayListRecorder(const GrSurfaceCharacterization&);
+    ~GrDeferredDisplayListRecorder();
+
+    const GrSurfaceCharacterization& characterization() const {
+        return fCharacterization;
+    }
+
+    // The backing canvas will become invalid (and this entry point will return
+    // null) once 'detach' is called.
+    // Note: ownership of the SkCanvas is not transferred via this call.
+    SkCanvas* getCanvas();
+
+    sk_sp<GrDeferredDisplayList> detach();
+
+    using PromiseImageTextureContext = void*;
+    using PromiseImageTextureFulfillProc =
+            sk_sp<GrPromiseImageTexture> (*)(PromiseImageTextureContext);
+    using PromiseImageTextureReleaseProc = void (*)(PromiseImageTextureContext);
+
+#ifndef SK_MAKE_PROMISE_TEXTURE_DISABLE_LEGACY_API
+    /** Deprecated: Use SkImages::PromiseTextureFrom instead. */
+    sk_sp<SkImage> makePromiseTexture(const GrBackendFormat& backendFormat,
+                                      int width,
+                                      int height,
+                                      GrMipmapped mipmapped,
+                                      GrSurfaceOrigin origin,
+                                      SkColorType colorType,
+                                      SkAlphaType alphaType,
+                                      sk_sp<SkColorSpace> colorSpace,
+                                      PromiseImageTextureFulfillProc textureFulfillProc,
+                                      PromiseImageTextureReleaseProc textureReleaseProc,
+                                      PromiseImageTextureContext textureContext);
+
+    /** Deprecated: Use SkImages::PromiseTextureFromYUVA instead. */
+    sk_sp<SkImage> makeYUVAPromiseTexture(const GrYUVABackendTextureInfo& yuvaBackendTextureInfo,
+                                          sk_sp<SkColorSpace> imageColorSpace,
+                                          PromiseImageTextureFulfillProc textureFulfillProc,
+                                          PromiseImageTextureReleaseProc textureReleaseProc,
+                                          PromiseImageTextureContext textureContexts[]);
+#endif // SK_MAKE_PROMISE_TEXTURE_DISABLE_LEGACY_API
+
+
+private:
+    GrDeferredDisplayListRecorder(const GrDeferredDisplayListRecorder&) = delete;
+    GrDeferredDisplayListRecorder& operator=(const GrDeferredDisplayListRecorder&) = delete;
+
+    bool init();
+
+    const GrSurfaceCharacterization             fCharacterization;
+    sk_sp<GrRecordingContext>                   fContext;
+    sk_sp<GrRenderTargetProxy>                  fTargetProxy;
+    sk_sp<GrDeferredDisplayList::LazyProxyData> fLazyProxyData;
+    sk_sp<SkSurface>                            fSurface;
+};
+
+#endif

package/cpp/skia/include/private/chromium/GrPromiseImageTexture.h

@@ -0,0 +1,43 @@
+/*
+ * 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 GrPromiseImageTexture_DEFINED
+#define GrPromiseImageTexture_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+#include "include/gpu/GrBackendSurface.h"
+/**
+ * This type is used to fulfill textures for PromiseImages. Once an instance is returned from a
+ * PromiseImageTextureFulfillProc the GrBackendTexture it wraps must remain valid until the
+ * corresponding PromiseImageTextureReleaseProc is called.
+ */
+class SK_API GrPromiseImageTexture : public SkNVRefCnt<GrPromiseImageTexture> {
+public:
+    GrPromiseImageTexture() = delete;
+    GrPromiseImageTexture(const GrPromiseImageTexture&) = delete;
+    GrPromiseImageTexture(GrPromiseImageTexture&&) = delete;
+    ~GrPromiseImageTexture();
+    GrPromiseImageTexture& operator=(const GrPromiseImageTexture&) = delete;
+    GrPromiseImageTexture& operator=(GrPromiseImageTexture&&) = delete;
+
+    static sk_sp<GrPromiseImageTexture> Make(const GrBackendTexture& backendTexture) {
+        if (!backendTexture.isValid()) {
+            return nullptr;
+        }
+        return sk_sp<GrPromiseImageTexture>(new GrPromiseImageTexture(backendTexture));
+    }
+
+    GrBackendTexture backendTexture() const { return fBackendTexture; }
+
+private:
+    explicit GrPromiseImageTexture(const GrBackendTexture& backendTexture);
+
+    GrBackendTexture fBackendTexture;
+};
+
+#endif // GrPromiseImageTexture_DEFINED

package/cpp/skia/include/private/chromium/GrSurfaceCharacterization.h

@@ -0,0 +1,215 @@
+/*
+ * 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 GrSurfaceCharacterization_DEFINED
+#define GrSurfaceCharacterization_DEFINED
+
+#include "include/core/SkColorSpace.h" // IWYU pragma: keep
+#include "include/core/SkColorType.h"
+#include "include/core/SkImageInfo.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSize.h"
+#include "include/core/SkSurfaceProps.h"
+#include "include/core/SkTypes.h"
+#include "include/gpu/GpuTypes.h"
+#include "include/gpu/GrBackendSurface.h"
+#include "include/gpu/GrContextThreadSafeProxy.h"
+#include "include/gpu/GrTypes.h"
+#include "include/private/base/SkDebug.h"
+
+#include <cstddef>
+#include <utility>
+
+/** \class GrSurfaceCharacterization
+    A surface characterization contains all the information Ganesh requires to makes its internal
+    rendering decisions. When passed into a GrDeferredDisplayListRecorder it will copy the
+    data and pass it on to the GrDeferredDisplayList if/when it is created. Note that both of
+    those objects (the Recorder and the DisplayList) will take a ref on the
+    GrContextThreadSafeProxy and SkColorSpace objects.
+*/
+class SK_API GrSurfaceCharacterization {
+public:
+    enum class Textureable : bool { kNo = false, kYes = true };
+    enum class MipMapped : bool { kNo = false, kYes = true };
+    enum class UsesGLFBO0 : bool { kNo = false, kYes = true };
+    // This flag indicates that the backing VkImage for this Vulkan surface will have the
+    // VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set. This bit allows skia to handle advanced blends
+    // more optimally in a shader by being able to directly read the dst values.
+    enum class VkRTSupportsInputAttachment : bool { kNo = false, kYes = true };
+    // This flag indicates if the surface is wrapping a raw Vulkan secondary command buffer.
+    enum class VulkanSecondaryCBCompatible : bool { kNo = false, kYes = true };
+
+    GrSurfaceCharacterization()
+            : fCacheMaxResourceBytes(0)
+            , fOrigin(kBottomLeft_GrSurfaceOrigin)
+            , fSampleCnt(0)
+            , fIsTextureable(Textureable::kYes)
+            , fIsMipMapped(MipMapped::kYes)
+            , fUsesGLFBO0(UsesGLFBO0::kNo)
+            , fVulkanSecondaryCBCompatible(VulkanSecondaryCBCompatible::kNo)
+            , fIsProtected(GrProtected::kNo)
+            , fSurfaceProps(0, kUnknown_SkPixelGeometry) {
+    }
+
+    GrSurfaceCharacterization(GrSurfaceCharacterization&&) = default;
+    GrSurfaceCharacterization& operator=(GrSurfaceCharacterization&&) = default;
+
+    GrSurfaceCharacterization(const GrSurfaceCharacterization&) = default;
+    GrSurfaceCharacterization& operator=(const GrSurfaceCharacterization& other) = default;
+    bool operator==(const GrSurfaceCharacterization& other) const;
+    bool operator!=(const GrSurfaceCharacterization& other) const {
+        return !(*this == other);
+    }
+
+    /*
+     * Return a new surface characterization with the only difference being a different width
+     * and height
+     */
+    GrSurfaceCharacterization createResized(int width, int height) const;
+
+    /*
+     * Return a new surface characterization with only a replaced color space
+     */
+    GrSurfaceCharacterization createColorSpace(sk_sp<SkColorSpace>) const;
+
+    /*
+     * Return a new surface characterization with the backend format replaced. A colorType
+     * must also be supplied to indicate the interpretation of the new format.
+     */
+    GrSurfaceCharacterization createBackendFormat(SkColorType colorType,
+                                                  const GrBackendFormat& backendFormat) const;
+
+    /*
+     * Return a new surface characterization with just a different use of FBO0 (in GL)
+     */
+    GrSurfaceCharacterization createFBO0(bool usesGLFBO0) const;
+
+    GrContextThreadSafeProxy* contextInfo() const { return fContextInfo.get(); }
+    sk_sp<GrContextThreadSafeProxy> refContextInfo() const { return fContextInfo; }
+    size_t cacheMaxResourceBytes() const { return fCacheMaxResourceBytes; }
+
+    bool isValid() const { return kUnknown_SkColorType != fImageInfo.colorType(); }
+
+    const SkImageInfo& imageInfo() const { return fImageInfo; }
+    const GrBackendFormat& backendFormat() const { return fBackendFormat; }
+    GrSurfaceOrigin origin() const { return fOrigin; }
+    SkISize dimensions() const { return fImageInfo.dimensions(); }
+    int width() const { return fImageInfo.width(); }
+    int height() const { return fImageInfo.height(); }
+    SkColorType colorType() const { return fImageInfo.colorType(); }
+    int sampleCount() const { return fSampleCnt; }
+    bool isTextureable() const { return Textureable::kYes == fIsTextureable; }
+    bool isMipMapped() const { return MipMapped::kYes == fIsMipMapped; }
+    bool usesGLFBO0() const { return UsesGLFBO0::kYes == fUsesGLFBO0; }
+    bool vkRTSupportsInputAttachment() const {
+        return VkRTSupportsInputAttachment::kYes == fVkRTSupportsInputAttachment;
+    }
+    bool vulkanSecondaryCBCompatible() const {
+        return VulkanSecondaryCBCompatible::kYes == fVulkanSecondaryCBCompatible;
+    }
+    GrProtected isProtected() const { return fIsProtected; }
+    SkColorSpace* colorSpace() const { return fImageInfo.colorSpace(); }
+    sk_sp<SkColorSpace> refColorSpace() const { return fImageInfo.refColorSpace(); }
+    const SkSurfaceProps& surfaceProps()const { return fSurfaceProps; }
+
+    // Is the provided backend texture compatible with this surface characterization?
+    bool isCompatible(const GrBackendTexture&) const;
+
+private:
+    friend class SkSurface_Ganesh;           // for 'set' & 'config'
+    friend class GrVkSecondaryCBDrawContext; // for 'set' & 'config'
+    friend class GrContextThreadSafeProxy; // for private ctor
+    friend class GrDeferredDisplayListRecorder; // for 'config'
+    friend class SkSurface; // for 'config'
+
+    SkDEBUGCODE(void validate() const;)
+
+    GrSurfaceCharacterization(sk_sp<GrContextThreadSafeProxy> contextInfo,
+                              size_t cacheMaxResourceBytes,
+                              const SkImageInfo& ii,
+                              const GrBackendFormat& backendFormat,
+                              GrSurfaceOrigin origin,
+                              int sampleCnt,
+                              Textureable isTextureable,
+                              MipMapped isMipMapped,
+                              UsesGLFBO0 usesGLFBO0,
+                              VkRTSupportsInputAttachment vkRTSupportsInputAttachment,
+                              VulkanSecondaryCBCompatible vulkanSecondaryCBCompatible,
+                              GrProtected isProtected,
+                              const SkSurfaceProps& surfaceProps)
+            : fContextInfo(std::move(contextInfo))
+            , fCacheMaxResourceBytes(cacheMaxResourceBytes)
+            , fImageInfo(ii)
+            , fBackendFormat(backendFormat)
+            , fOrigin(origin)
+            , fSampleCnt(sampleCnt)
+            , fIsTextureable(isTextureable)
+            , fIsMipMapped(isMipMapped)
+            , fUsesGLFBO0(usesGLFBO0)
+            , fVkRTSupportsInputAttachment(vkRTSupportsInputAttachment)
+            , fVulkanSecondaryCBCompatible(vulkanSecondaryCBCompatible)
+            , fIsProtected(isProtected)
+            , fSurfaceProps(surfaceProps) {
+        if (fSurfaceProps.flags() & SkSurfaceProps::kDynamicMSAA_Flag) {
+            // Dynamic MSAA is not currently supported with DDL.
+            *this = {};
+        }
+        SkDEBUGCODE(this->validate());
+    }
+
+    void set(sk_sp<GrContextThreadSafeProxy> contextInfo,
+             size_t cacheMaxResourceBytes,
+             const SkImageInfo& ii,
+             const GrBackendFormat& backendFormat,
+             GrSurfaceOrigin origin,
+             int sampleCnt,
+             Textureable isTextureable,
+             MipMapped isMipMapped,
+             UsesGLFBO0 usesGLFBO0,
+             VkRTSupportsInputAttachment vkRTSupportsInputAttachment,
+             VulkanSecondaryCBCompatible vulkanSecondaryCBCompatible,
+             GrProtected isProtected,
+             const SkSurfaceProps& surfaceProps) {
+        if (surfaceProps.flags() & SkSurfaceProps::kDynamicMSAA_Flag) {
+            // Dynamic MSAA is not currently supported with DDL.
+            *this = {};
+        } else {
+            fContextInfo = contextInfo;
+            fCacheMaxResourceBytes = cacheMaxResourceBytes;
+
+            fImageInfo = ii;
+            fBackendFormat = backendFormat;
+            fOrigin = origin;
+            fSampleCnt = sampleCnt;
+            fIsTextureable = isTextureable;
+            fIsMipMapped = isMipMapped;
+            fUsesGLFBO0 = usesGLFBO0;
+            fVkRTSupportsInputAttachment = vkRTSupportsInputAttachment;
+            fVulkanSecondaryCBCompatible = vulkanSecondaryCBCompatible;
+            fIsProtected = isProtected;
+            fSurfaceProps = surfaceProps;
+        }
+        SkDEBUGCODE(this->validate());
+    }
+
+    sk_sp<GrContextThreadSafeProxy> fContextInfo;
+    size_t                          fCacheMaxResourceBytes;
+
+    SkImageInfo                     fImageInfo;
+    GrBackendFormat                 fBackendFormat;
+    GrSurfaceOrigin                 fOrigin;
+    int                             fSampleCnt;
+    Textureable                     fIsTextureable;
+    MipMapped                       fIsMipMapped;
+    UsesGLFBO0                      fUsesGLFBO0;
+    VkRTSupportsInputAttachment     fVkRTSupportsInputAttachment;
+    VulkanSecondaryCBCompatible     fVulkanSecondaryCBCompatible;
+    GrProtected                     fIsProtected;
+    SkSurfaceProps                  fSurfaceProps;
+};
+
+#endif

package/cpp/skia/include/private/chromium/GrVkSecondaryCBDrawContext.h

@@ -15,15 +15,15 @@
 #include <memory>
 
 class GrBackendSemaphore;
+class GrDeferredDisplayList;
 class GrRecordingContext;
+class GrSurfaceCharacterization;
 struct GrVkDrawableInfo;
 namespace skgpu::ganesh {
 class Device;
 }
 class SkCanvas;
-class SkDeferredDisplayList;
 struct SkImageInfo;
-class SkSurfaceCharacterization;
 class SkSurfaceProps;
 
 /**
@@ -107,15 +107,15 @@ public:
     const SkSurfaceProps& props() const { return fProps; }
 
     // TODO: Fill out these calls to support DDL
-    bool characterize(SkSurfaceCharacterization* characterization) const;
+    bool characterize(GrSurfaceCharacterization* characterization) const;
 
 #ifndef SK_DDL_IS_UNIQUE_POINTER
-    bool draw(sk_sp<const SkDeferredDisplayList> deferredDisplayList);
+    bool draw(sk_sp<const GrDeferredDisplayList> deferredDisplayList);
 #else
-    bool draw(const SkDeferredDisplayList* deferredDisplayList);
+    bool draw(const GrDeferredDisplayList* deferredDisplayList);
 #endif
 
-    bool isCompatible(const SkSurfaceCharacterization& characterization) const;
+    bool isCompatible(const GrSurfaceCharacterization& characterization) const;
 
 private:
     explicit GrVkSecondaryCBDrawContext(sk_sp<skgpu::ganesh::Device>, const SkSurfaceProps*);

package/cpp/skia/include/private/chromium/SkImageChromium.h

@@ -0,0 +1,104 @@
+/*
+ * 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 SkImageChromium_DEFINED
+#define SkImageChromium_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/GrTypes.h"
+#include "include/private/base/SkAPI.h"
+
+class GrBackendFormat;
+class GrContextThreadSafeProxy;
+class GrPromiseImageTexture;
+class GrYUVABackendTextureInfo;
+class SkColorSpace;
+class SkImage;
+enum SkAlphaType : int;
+enum SkColorType : int;
+struct SkISize;
+
+/**
+ * These functions expose features that are only for external use in Chromium.
+ */
+
+namespace SkImages {
+
+using PromiseImageTextureContext = void*;
+using PromiseImageTextureFulfillProc = sk_sp<GrPromiseImageTexture> (*)(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 GrDeferredDisplayListRecorder 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[]);
+
+}  // namespace SkImages
+
+#endif