@shopify/react-native-skia 0.1.234 → 0.1.237

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

@@ -8,6 +8,7 @@
 #ifndef skgpu_graphite_Image_DEFINED
 #define skgpu_graphite_Image_DEFINED
 
+#include "include/core/SkColorSpace.h"
 #include "include/core/SkImage.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSpan.h"
@@ -45,7 +46,8 @@ using GraphitePromiseImageYUVAFulfillProc =
 using GraphitePromiseImageReleaseProc = void (*)(GraphitePromiseImageContext);
 using GraphitePromiseTextureReleaseProc = void (*)(GraphitePromiseTextureReleaseContext);
 
-/** Creates an SkImage from a GPU texture associated with the recorder.
+/** Creates an SkImage from a GPU texture associated with the recorder. The client is still
+    responsible for managing the backend texture's lifetime.
 
     SkImage is returned if the format of backendTexture is recognized and supported.
     Recognized formats vary by GPU back-end.
@@ -63,57 +65,77 @@ using GraphitePromiseTextureReleaseProc = void (*)(GraphitePromiseTextureRelease
                                BottomLeft
     @return                    created SkImage, or nullptr
 */
-SK_API sk_sp<SkImage> AdoptTextureFrom(skgpu::graphite::Recorder*,
-                                       const skgpu::graphite::BackendTexture&,
+SK_API sk_sp<SkImage> WrapTexture(skgpu::graphite::Recorder*,
+                                  const skgpu::graphite::BackendTexture&,
+                                  SkColorType colorType,
+                                  SkAlphaType alphaType,
+                                  sk_sp<SkColorSpace> colorSpace,
+                                  skgpu::Origin origin,
+                                  TextureReleaseProc = nullptr,
+                                  ReleaseContext = nullptr);
+
+SK_API sk_sp<SkImage> WrapTexture(skgpu::graphite::Recorder*,
+                                  const skgpu::graphite::BackendTexture&,
+                                  SkColorType colorType,
+                                  SkAlphaType alphaType,
+                                  sk_sp<SkColorSpace> colorSpace,
+                                  TextureReleaseProc = nullptr,
+                                  ReleaseContext = nullptr);
+
+#if !defined(SK_DISABLE_LEGACY_GRAPHITE_IMAGES)
+inline sk_sp<SkImage> AdoptTextureFrom(skgpu::graphite::Recorder* recorder,
+                                       const skgpu::graphite::BackendTexture& tex,
                                        SkColorType colorType,
                                        SkAlphaType alphaType,
                                        sk_sp<SkColorSpace> colorSpace,
                                        skgpu::Origin origin,
-                                       TextureReleaseProc = nullptr,
-                                       ReleaseContext = nullptr);
+                                       TextureReleaseProc trProc = nullptr,
+                                       ReleaseContext ctx = nullptr) {
+    return WrapTexture(recorder, tex, colorType, alphaType, colorSpace, origin, trProc, ctx);
+}
 
-SK_API sk_sp<SkImage> AdoptTextureFrom(skgpu::graphite::Recorder*,
-                                       const skgpu::graphite::BackendTexture&,
+inline sk_sp<SkImage> AdoptTextureFrom(skgpu::graphite::Recorder* recorder,
+                                       const skgpu::graphite::BackendTexture& tex,
                                        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.
+                                       TextureReleaseProc trProc = nullptr,
+                                       ReleaseContext ctx = nullptr) {
+    return WrapTexture(recorder, tex, colorType, alphaType, colorSpace, trProc, ctx);
+}
+#endif
+
+/** Create a new SkImage that is very similar to an SkImage created by WrapTexture. 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
@@ -150,16 +172,16 @@ SK_API sk_sp<SkImage> PromiseTextureFrom(skgpu::graphite::Recorder*,
                                          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.
+    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
@@ -184,19 +206,19 @@ SK_API sk_sp<SkImage> PromiseTextureFromYUVA(skgpu::graphite::Recorder*,
                                              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.
+/** 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 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.
+    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)
@@ -207,20 +229,19 @@ SK_API sk_sp<SkImage> TextureFromImage(skgpu::graphite::Recorder*,
                                        SkImage::RequiredProperties = {});
 
 inline sk_sp<SkImage> TextureFromImage(skgpu::graphite::Recorder* r,
-                                       sk_sp<const SkImage> img,
+                                       const 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.
+    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).
+    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.
 
@@ -259,10 +280,10 @@ SK_API sk_sp<SkImage> TextureFromYUVATextures(
 
 /** 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.
+    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
@@ -297,19 +318,17 @@ SK_API sk_sp<SkImage> SubsetTextureFrom(skgpu::graphite::Recorder* recorder,
                                         SkImage::RequiredProperties props = {});
 
 /** Creates a filtered SkImage on the GPU. filter processes the src image, potentially changing
-    color, position, and size. subset is the bounds of src that are processed
-    by filter. clipBounds is the expected bounds of the filtered SkImage. outSubset
-    is required storage for the actual bounds of the filtered SkImage. offset is
-    required storage for translation of returned SkImage.
-
-    Returns nullptr if SkImage could not be created. If nullptr is returned, outSubset
-    and offset are undefined.
-
-    Useful for animation of SkImageFilter that varies size from frame to frame.
-    Returned SkImage is created larger than required by filter so that GPU texture
-    can be reused with different sized effects. outSubset describes the valid bounds
-    of GPU texture returned. offset translates the returned SkImage to keep subsequent
-    animation frames aligned with respect to each other.
+    color, position, and size. subset is the bounds of src that are processed by filter. clipBounds
+    is the expected bounds of the filtered SkImage. outSubset is required storage for the actual
+    bounds of the filtered SkImage. offset is required storage for translation of returned SkImage.
+
+    Returns nullptr if SkImage could not be created. If nullptr is returned, outSubset and offset
+    are undefined.
+
+    Useful for animation of SkImageFilter that varies size from frame to frame. Returned SkImage is
+    created larger than required by filter so that GPU texture can be reused with different sized
+    effects. outSubset describes the valid bounds of GPU texture returned. offset translates the
+    returned SkImage to keep subsequent animation frames aligned with respect to each other.
 
     @param recorder    the recorder in which the filtering operation is to be performed
     @param filter      how SkImage is sampled when transformed

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

@@ -18,9 +18,11 @@
 #include <chrono>
 #include <vector>
 
+struct AHardwareBuffer;
 class SkCanvas;
 struct SkImageInfo;
 class SkPixmap;
+class SkTraceMemoryDump;
 
 namespace skgpu {
 class RefCntedCallback;
@@ -65,7 +67,7 @@ struct SK_API RecorderOptions final {
 
     sk_sp<ImageProvider> fImageProvider;
 
-    const size_t kDefaultRecorderBudget = 256 * (1 << 20);
+    static constexpr size_t kDefaultRecorderBudget = 256 * (1 << 20);
     // What is the budget for GPU resources allocated and held by this Recorder.
     size_t fGpuBudgetInBytes = kDefaultRecorderBudget;
 };
@@ -79,6 +81,8 @@ public:
 
     ~Recorder();
 
+    BackendApi backend() const;
+
     std::unique_ptr<Recording> snap();
 
     ImageProvider* clientImageProvider() { return fClientImageProvider.get(); }
@@ -97,6 +101,14 @@ public:
      */
     BackendTexture createBackendTexture(SkISize dimensions, const TextureInfo&);
 
+#ifdef SK_BUILD_FOR_ANDROID
+    BackendTexture createBackendTexture(AHardwareBuffer*,
+                                        bool isRenderable,
+                                        bool isProtectedContent,
+                                        SkISize dimensions,
+                                        bool fromAndroidWindow = false) const;
+#endif
+
     /**
      * If possible, updates a backend texture with the provided pixmap data. The client
      * should check the return value to see if the update was successful. The client is required
@@ -154,6 +166,17 @@ public:
      */
     void performDeferredCleanup(std::chrono::milliseconds msNotUsed);
 
+    /**
+     * Returns the number of bytes of gpu memory currently budgeted in the Recorder's cache.
+     */
+    size_t currentBudgetedBytes() const;
+
+    /**
+     * Enumerates all cached GPU resources owned by the Recorder and dumps their memory to
+     * traceMemoryDump.
+     */
+    void dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const;
+
     // Provides access to functions that aren't part of the public API.
     RecorderPriv priv();
     const RecorderPriv priv() const;  // NOLINT(readability-const-return-type)
@@ -167,8 +190,6 @@ private:
 
     SingleOwner* singleOwner() const { return &fSingleOwner; }
 
-    BackendApi backend() const;
-
     // We keep track of all Devices that are connected to a Recorder. This allows the client to
     // safely delete an SkSurface or a Recorder in any order. If the client deletes the Recorder
     // we need to notify all Devices that the Recorder is no longer valid. If we delete the

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

@@ -21,8 +21,11 @@ class Recorder;
 }  // namespace skgpu::graphite
 
 namespace SkSurfaces {
+using ReleaseContext = void*;
+using TextureReleaseProc = void (*)(ReleaseContext);
+
 /**
- * The 'asImage' and 'makeImageCopy' API/entry points are currently only available for
+ * The 'AsImage' and 'AsImageCopy' API/entry points are currently only available for
  * Graphite.
  *
  * In this API, SkSurface no longer supports copy-on-write behavior. Instead, when creating
@@ -75,7 +78,9 @@ SK_API sk_sp<SkSurface> WrapBackendTexture(skgpu::graphite::Recorder*,
                                            const skgpu::graphite::BackendTexture&,
                                            SkColorType colorType,
                                            sk_sp<SkColorSpace> colorSpace,
-                                           const SkSurfaceProps* props);
+                                           const SkSurfaceProps* props,
+                                           TextureReleaseProc = nullptr,
+                                           ReleaseContext = nullptr);
 }  // namespace SkSurfaces
 
 #endif  // skgpu_graphite_Surface_DEFINED

package/cpp/skia/include/gpu/graphite/dawn/DawnBackendContext.h

@@ -8,16 +8,55 @@
 #ifndef skgpu_graphite_DawnBackendContext_DEFINED
 #define skgpu_graphite_DawnBackendContext_DEFINED
 
-#include "webgpu/webgpu_cpp.h"
+#include "include/core/SkTypes.h"
+#include "webgpu/webgpu_cpp.h"  // NO_G3_REWRITE
 
 namespace skgpu::graphite {
 
+/**
+ * WebGPU needs to allow the main thread loop to run to detect GPU progress. Dawn native has a
+ * function wgpu::Dawn::Tick(), not present in WebGPU, that can be used to detect GPU progress.
+ *
+ * When compiling using Emscripten/WASM the -s ASYNCIFY option can be used to yield. E.g.:
+ *
+ * EM_ASYNC_JS(void, asyncSleep, (), {
+ *                 await new Promise((resolve, _) = > {
+ *                     setTimeout(resolve, 0);
+ *                 })
+ *             });
+ *
+ * WebGPUTickFunction(wgpu::Device&) { asyncSleep(); }
+ *
+ * If no DawnTickFunction is provided then the graphite::Context will be "non-yielding". This
+ * implies the following restrictions on the Context:
+ *
+ * 1) SyncToCpu::kYes is disallowed as a parameter to Context::submit.
+ * 2) The client must guarantee that GPU work has completed before destroying Context as Context
+ *    cannot await the work completion in its destructor. Context reports whether it is awaiting
+ *    GPU work completion via Context::hasUnfinishedGpuWork().
+ *
+ * Using a non-yielding Context makes it possible to build and run Graphite/Dawn on WebGPU without
+ * -s ASYNCIFY.
+ */
+using DawnTickFunction = void(const wgpu::Device& device);
+
+#if !defined(__EMSCRIPTEN__)
+SK_API inline void DawnNativeTickFunction(const wgpu::Device& device) { device.Tick(); }
+#endif
+
 // The DawnBackendContext contains all of the base Dawn objects needed by the graphite Dawn
 // backend. The client will create this object and pass it into the Context::MakeDawn factory call
 // when setting up Skia.
 struct SK_API DawnBackendContext {
     wgpu::Device fDevice;
-    wgpu::Queue  fQueue;
+    wgpu::Queue fQueue;
+    // See comment on DawnTickFunction.
+    DawnTickFunction* fTick =
+#if defined(__EMSCRIPTEN__)
+            nullptr;
+#else
+            DawnNativeTickFunction;
+#endif
 };
 
 } // namespace skgpu::graphite

package/cpp/skia/include/gpu/graphite/dawn/DawnTypes.h

@@ -9,7 +9,7 @@
 #define skgpu_graphite_DawnTypes_DEFINED
 
 #include "include/gpu/graphite/GraphiteTypes.h"
-#include "webgpu/webgpu_cpp.h"
+#include "webgpu/webgpu_cpp.h"  // NO_G3_REWRITE
 
 namespace skgpu::graphite {
 
@@ -18,19 +18,24 @@ struct DawnTextureInfo {
     Mipmapped fMipmapped = Mipmapped::kNo;
 
     // wgpu::TextureDescriptor properties
+    // `fFormat` for multiplanar formats corresponds to the plane TextureView's format.
     wgpu::TextureFormat fFormat = wgpu::TextureFormat::Undefined;
-    wgpu::TextureUsage  fUsage = wgpu::TextureUsage::None;
+    wgpu::TextureUsage fUsage = wgpu::TextureUsage::None;
+    // TODO(b/308944094): Migrate aspect information to BackendTextureViews.
+    wgpu::TextureAspect fAspect = wgpu::TextureAspect::All;
 
     DawnTextureInfo() = default;
     DawnTextureInfo(const wgpu::Texture& texture);
     DawnTextureInfo(uint32_t sampleCount,
                     Mipmapped mipmapped,
-                    wgpu::TextureFormat format,
-                    wgpu::TextureUsage usage)
+                    wgpu::TextureFormat viewFormat,
+                    wgpu::TextureUsage usage,
+                    wgpu::TextureAspect aspect)
             : fSampleCount(sampleCount)
             , fMipmapped(mipmapped)
-            , fFormat(format)
-            , fUsage(usage) {}
+            , fFormat(viewFormat)
+            , fUsage(usage)
+            , fAspect(aspect) {}
 };
 
 } // namespace skgpu::graphite

package/cpp/skia/include/gpu/graphite/mtl/MtlGraphiteTypes.h

@@ -35,7 +35,6 @@ namespace skgpu::graphite {
 using MtlPixelFormat = unsigned int;
 using MtlTextureUsage = unsigned int;
 using MtlStorageMode = unsigned int;
-using MtlHandle = const void*;
 
 struct MtlTextureInfo {
     uint32_t fSampleCount = 1;
@@ -49,7 +48,7 @@ struct MtlTextureInfo {
     bool fFramebufferOnly = false;
 
     MtlTextureInfo() = default;
-    MtlTextureInfo(MtlHandle mtlTexture);
+    MtlTextureInfo(CFTypeRef mtlTexture);
     MtlTextureInfo(uint32_t sampleCount,
                    skgpu::Mipmapped mipmapped,
                    MtlPixelFormat format,

package/cpp/skia/include/gpu/graphite/vk/VulkanGraphiteTypes.h

@@ -33,10 +33,8 @@ struct VulkanTextureInfo {
     // However, if the VkImage is a Ycbcr format, the client can pass a specific plan here to have
     // Skia directly sample a plane. In that case the client should also pass in a VkFormat that is
     // compatible with the plane as described by the Vulkan spec.
-    VkImageAspectFlags fAspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-    // TODO: Either Make the ycbcr conversion info shareable with Ganesh or add a version for
-    // Graphite.
-    // GrVkYcbcrConversionInfo  fYcbcrConversionInfo;
+    VkImageAspectFlags         fAspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    VulkanYcbcrConversionInfo  fYcbcrConversionInfo;
 
     VulkanTextureInfo() = default;
     VulkanTextureInfo(uint32_t sampleCount,
@@ -46,7 +44,8 @@ struct VulkanTextureInfo {
                       VkImageTiling imageTiling,
                       VkImageUsageFlags imageUsageFlags,
                       VkSharingMode sharingMode,
-                      VkImageAspectFlags aspectMask)
+                      VkImageAspectFlags aspectMask,
+                      VulkanYcbcrConversionInfo ycbcrConversionInfo)
             : fSampleCount(sampleCount)
             , fMipmapped(mipmapped)
             , fFlags(flags)
@@ -54,7 +53,8 @@ struct VulkanTextureInfo {
             , fImageTiling(imageTiling)
             , fImageUsageFlags(imageUsageFlags)
             , fSharingMode(sharingMode)
-            , fAspectMask(aspectMask) {}
+            , fAspectMask(aspectMask)
+            , fYcbcrConversionInfo(ycbcrConversionInfo) {}
 };
 
 } // namespace skgpu::graphite

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

@@ -121,6 +121,7 @@ struct GrMockOptions {
         fConfigOptions[(int)GrColorType::kRGBA_8888].fTexturable = true;
         fConfigOptions[(int)GrColorType::kAlpha_8].fTexturable = true;
         fConfigOptions[(int)GrColorType::kBGR_565].fTexturable = true;
+        fConfigOptions[(int)GrColorType::kRGB_565].fTexturable = true;
 
         fConfigOptions[(int)GrColorType::kBGRA_8888] = fConfigOptions[(int)GrColorType::kRGBA_8888];
 

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

@@ -30,7 +30,7 @@ enum GrVkFeatureFlags {
     kSampleRateShading_GrVkFeatureFlag = 0x0004,
 };
 
-// It is not guarenteed VkPhysicalDeviceProperties2 will be in the client's header so we forward
+// It is not guaranteed VkPhysicalDeviceProperties2 will be in the client's header so we forward
 // declare it here to be safe.
 struct VkPhysicalDeviceFeatures2;
 

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

@@ -14,50 +14,7 @@
 
 using GrVkBackendMemory = skgpu::VulkanBackendMemory;
 using GrVkAlloc = skgpu::VulkanAlloc;
-
-// This struct is used to pass in the necessary information to create a VkSamplerYcbcrConversion
-// object for an VkExternalFormatANDROID.
-struct GrVkYcbcrConversionInfo {
-    bool operator==(const GrVkYcbcrConversionInfo& that) const {
-        // Invalid objects are not required to have all other fields initialized or matching.
-        if (!this->isValid() && !that.isValid()) {
-            return true;
-        }
-        return this->fFormat == that.fFormat &&
-               this->fExternalFormat == that.fExternalFormat &&
-               this->fYcbcrModel == that.fYcbcrModel &&
-               this->fYcbcrRange == that.fYcbcrRange &&
-               this->fXChromaOffset == that.fXChromaOffset &&
-               this->fYChromaOffset == that.fYChromaOffset &&
-               this->fChromaFilter == that.fChromaFilter &&
-               this->fForceExplicitReconstruction == that.fForceExplicitReconstruction;
-    }
-    bool operator!=(const GrVkYcbcrConversionInfo& that) const { return !(*this == that); }
-
-    bool isValid() const {
-        return fYcbcrModel != VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY ||
-               fExternalFormat != 0;
-    }
-
-    // Format of the source image. Must be set to VK_FORMAT_UNDEFINED for external images or
-    // a valid image format otherwise.
-    VkFormat fFormat = VK_FORMAT_UNDEFINED;
-
-    // The external format. Must be non-zero for external images, zero otherwise.
-    // Should be compatible to be used in a VkExternalFormatANDROID struct.
-    uint64_t fExternalFormat = 0;
-
-    VkSamplerYcbcrModelConversion fYcbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
-    VkSamplerYcbcrRange fYcbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_FULL;
-    VkChromaLocation fXChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN;
-    VkChromaLocation fYChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN;
-    VkFilter fChromaFilter = VK_FILTER_NEAREST;
-    VkBool32 fForceExplicitReconstruction = false;
-
-    // For external images format features here should be those returned by a call to
-    // vkAndroidHardwareBufferFormatPropertiesANDROID
-    VkFormatFeatureFlags fFormatFeatures = 0;
-};
+using GrVkYcbcrConversionInfo = skgpu::VulkanYcbcrConversionInfo;
 
 /*
  * When wrapping a GrBackendTexture or GrBackendRendenderTarget, the fCurrentQueueFamily should

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

@@ -57,7 +57,7 @@ public:
 #endif
 
 private:
-    void getSpecVersions(VulkanGetProc getProc, VkInstance, VkPhysicalDevice);
+    void getSpecVersions(const VulkanGetProc& getProc, VkInstance, VkPhysicalDevice);
 
     skia_private::TArray<Info> fExtensions;
 };

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

@@ -0,0 +1,25 @@
+/*
+ * 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_VulkanMutableTextureState_DEFINED
+#define skgpu_VulkanMutableTextureState_DEFINED
+
+#include "include/gpu/MutableTextureState.h"
+#include "include/private/gpu/vk/SkiaVulkan.h"
+
+#include <cstdint>
+
+namespace skgpu::MutableTextureStates {
+    MutableTextureState MakeVulkan(VkImageLayout layout, uint32_t queueFamilyIndex);
+
+    VkImageLayout GetVkImageLayout(const MutableTextureState& state);
+    VkImageLayout GetVkImageLayout(const MutableTextureState* state);
+    uint32_t GetVkQueueFamilyIndex(const MutableTextureState& state);
+    uint32_t GetVkQueueFamilyIndex(const MutableTextureState* state);
+}
+
+#endif