@shopify/react-native-skia 0.1.233 → 0.1.236

package/cpp/skia/include/gpu/ganesh/vk/GrVkDirectContext.h

@@ -0,0 +1,30 @@
+/*
+ * 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 GrVkDirectContext_DEFINED
+#define GrVkDirectContext_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+class GrDirectContext;
+struct GrContextOptions;
+struct GrVkBackendContext;
+
+namespace GrDirectContexts {
+/**
+ * The Vulkan context (VkQueue, VkDevice, VkInstance) must be kept alive until the returned
+ * GrDirectContext is destroyed. This also means that any objects created with this
+ * GrDirectContext (e.g. SkSurfaces, SkImages, etc.) must also be released as they may hold
+ * refs on the GrDirectContext. Once all these objects and the GrDirectContext are released,
+ * then it is safe to delete the vulkan objects.
+ */
+SK_API sk_sp<GrDirectContext> MakeVulkan(const GrVkBackendContext&, const GrContextOptions&);
+SK_API sk_sp<GrDirectContext> MakeVulkan(const GrVkBackendContext&);
+}
+
+#endif

package/cpp/skia/include/gpu/gl/GrGLFunctions.h

@@ -268,7 +268,7 @@ public:
         if (fn_ptr) {
             memcpy(fBuf, &fn_ptr, sizeof(fn_ptr));
             fCall = [](const void* buf, Args... args) {
-                return (*(Fn**)buf)(std::forward<Args>(args)...);
+                return (*(Fn* const *)buf)(std::forward<Args>(args)...);
             };
         }
     }

package/cpp/skia/include/gpu/gl/GrGLInterface.h

@@ -18,6 +18,7 @@ typedef void(*GrGLFuncPtr)();
 struct GrGLInterface;
 
 
+#if !defined(SK_DISABLE_LEGACY_GL_MAKE_NATIVE_INTERFACE)
 /**
  * Rather than depend on platform-specific GL headers and libraries, we require
  * the client to provide a struct of GL function pointers. This struct can be
@@ -31,6 +32,7 @@ struct GrGLInterface;
  * appropriate one to build.
  */
 SK_API sk_sp<const GrGLInterface> GrGLMakeNativeInterface();
+#endif
 
 /**
  * GrContext uses the following interface to make all calls into OpenGL. When a

package/cpp/skia/include/gpu/gl/glx/GrGLMakeGLXInterface.h

@@ -11,4 +11,10 @@
 
 struct GrGLInterface;
 
+namespace GrGLInterfaces {
+sk_sp<const GrGLInterface> MakeGLX();
+}
+
+#if !defined(SK_DISABLE_LEGACY_GLXINTERFACE_FACTORY)
 sk_sp<const GrGLInterface> GrGLMakeGLXInterface();
+#endif

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

@@ -26,7 +26,7 @@ public:
     BackendSemaphore();
 #ifdef SK_METAL
     // TODO: Determine creator's responsibility for setting refcnt.
-    BackendSemaphore(MtlHandle mtlEvent, uint64_t value);
+    BackendSemaphore(CFTypeRef mtlEvent, uint64_t value);
 #endif
 
 #ifdef SK_VULKAN
@@ -43,7 +43,7 @@ public:
     BackendApi backend() const { return fBackend; }
 
 #ifdef SK_METAL
-    MtlHandle getMtlEvent() const;
+    CFTypeRef getMtlEvent() const;
     uint64_t getMtlValue() const;
 #endif
 
@@ -59,7 +59,7 @@ private:
 #endif
 #ifdef SK_METAL
         struct {
-            MtlHandle fMtlEvent;    // Expected to be an id<MTLEvent>
+            CFTypeRef fMtlEvent;    // Expected to be an id<MTLEvent>
             uint64_t fMtlValue;
         };
 #endif

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

@@ -28,7 +28,6 @@
 
 namespace skgpu {
 class MutableTextureState;
-class MutableTextureStateRef;
 }
 
 namespace skgpu::graphite {
@@ -37,33 +36,46 @@ class SK_API BackendTexture {
 public:
     BackendTexture();
 #ifdef SK_DAWN
-    // Create a BackendTexture from a WGPUTexture. Texture info will be
-    // queried from the texture. Comparing to WGPUTextureView,
-    // SkImage::readPixels(), SkSurface::readPixels() and
-    // SkSurface::writePixels() are implemented by direct buffer copy. They
-    // should be more efficient. For WGPUTextureView, those methods will use
-    // create an intermediate WGPUTexture, and use it to transfer pixels.
-    // Note:
-    //  - for better performance, using WGPUTexture IS RECOMMENDED.
-    //  - The BackendTexture will not call retain or release on the passed in
-    //  WGPUTexture. Thus the client must keep the WGPUTexture valid until
-    //  they are no longer using the BackendTexture.
+    // Create a BackendTexture from a WGPUTexture. Texture info will be queried from the texture.
+    //
+    // This is the recommended way of specifying a BackendTexture for Dawn. See the note below on
+    // the constructor that takes a WGPUTextureView for a fuller explanation.
+    //
+    // The BackendTexture will not call retain or release on the passed in WGPUTexture. Thus, the
+    // client must keep the WGPUTexture valid until they are no longer using the BackendTexture.
+    // However, any SkImage or SkSurface that wraps the BackendTexture *will* retain and release
+    // the WGPUTexture.
     BackendTexture(WGPUTexture texture);
+
+    // Create a BackendTexture from a WGPUTexture. Texture planeDimensions, plane aspect and
+    // info have to be provided. This is intended to be used only when accessing a plane
+    // of a WGPUTexture.
+    //
+    // The BackendTexture will not call retain or release on the passed in WGPUTexture. Thus, the
+    // client must keep the WGPUTexture valid until they are no longer using the BackendTexture.
+    // However, any SkImage or SkSurface that wraps the BackendTexture *will* retain and release
+    // the WGPUTexture.
+    BackendTexture(SkISize planeDimensions, const DawnTextureInfo& info, WGPUTexture texture);
+
     // Create a BackendTexture from a WGPUTextureView. Texture dimensions and
     // info have to be provided.
-    // Note:
-    //  - this method is for importing WGPUTextureView from wgpu::SwapChain only.
-    //  - The BackendTexture will not call retain or release on the passed in
-    //  WGPUTextureView. Thus the client must keep the WGPUTextureView valid
-    //  until they are no longer using the BackendTexture.
-    BackendTexture(SkISize dimensions,
-                   const DawnTextureInfo& info,
-                   WGPUTextureView textureView);
+    //
+    // Using a WGPUTextureView rather than a WGPUTexture is less effecient for operations that
+    // require buffer transfers to or from the texture (e.g. methods on graphite::Context that read
+    // pixels or SkSurface::writePixels). In such cases an intermediate copy to or from a
+    // WGPUTexture is required. Thus, it is recommended to use this functionality only for cases
+    // where a WGPUTexture is unavailable, in particular when using wgpu::SwapChain.
+    //
+    // The BackendTexture will not call retain or release on the passed in WGPUTextureView. Thus,
+    // the client must keep the WGPUTextureView valid until they are no longer using the
+    // BackendTexture. However, any SkImage or SkSurface that wraps the BackendTexture *will* retain
+    // and release the WGPUTextureView.
+    BackendTexture(SkISize dimensions, const DawnTextureInfo& info, WGPUTextureView textureView);
 #endif
 #ifdef SK_METAL
-    // The BackendTexture will not call retain or release on the passed in MtlHandle. Thus the
-    // client must keep the MtlHandle valid until they are no longer using the BackendTexture.
-    BackendTexture(SkISize dimensions, MtlHandle mtlTexture);
+    // The BackendTexture will not call retain or release on the passed in CFTypeRef. Thus the
+    // client must keep the CFTypeRef valid until they are no longer using the BackendTexture.
+    BackendTexture(SkISize dimensions, CFTypeRef mtlTexture);
 #endif
 
 #ifdef SK_VULKAN
@@ -103,7 +115,7 @@ public:
     WGPUTextureView getDawnTextureViewPtr() const;
 #endif
 #ifdef SK_METAL
-    MtlHandle getMtlTexture() const;
+    CFTypeRef getMtlTexture() const;
 #endif
 
 #ifdef SK_VULKAN
@@ -115,12 +127,12 @@ public:
 
 private:
     friend class VulkanResourceProvider;    // for getMutableState
-    sk_sp<MutableTextureStateRef> getMutableState() const;
+    sk_sp<MutableTextureState> getMutableState() const;
 
     SkISize fDimensions;
     TextureInfo fInfo;
 
-    sk_sp<MutableTextureStateRef> fMutableState;
+    sk_sp<MutableTextureState> fMutableState;
 
 #ifdef SK_VULKAN
     // fMemoryAlloc == VulkanAlloc() if the client has already created their own VkImage and
@@ -137,7 +149,7 @@ private:
         };
 #endif
 #ifdef SK_METAL
-        MtlHandle fMtlTexture;
+        CFTypeRef fMtlTexture;
 #endif
 #ifdef SK_VULKAN
         VkImage fVkImage = VK_NULL_HANDLE;

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

@@ -22,6 +22,7 @@
 
 class SkColorSpace;
 class SkRuntimeEffect;
+class SkTraceMemoryDump;
 
 namespace skgpu::graphite {
 
@@ -55,6 +56,9 @@ public:
     bool insertRecording(const InsertRecordingInfo&);
     bool submit(SyncToCpu = SyncToCpu::kNo);
 
+    /** Returns true if there is work that was submitted to the GPU that has not finished. */
+    bool hasUnfinishedGpuWork() const;
+
     void asyncRescaleAndReadPixels(const SkImage* image,
                                    const SkImageInfo& dstImageInfo,
                                    const SkIRect& srcRect,
@@ -142,6 +146,22 @@ public:
      */
     void performDeferredCleanup(std::chrono::milliseconds msNotUsed);
 
+    /**
+     * Returns the number of bytes of gpu memory currently budgeted in the Context's cache.
+     */
+    size_t currentBudgetedBytes() const;
+
+    /**
+     * Enumerates all cached GPU resources owned by the Context and dumps their memory to
+     * traceMemoryDump.
+     */
+    void dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const;
+
+    /*
+     * Does this context support protected content?
+     */
+    bool supportsProtectedContent() const;
+
     // Provides access to functions that aren't part of the public API.
     ContextPriv priv();
     const ContextPriv priv() const;  // NOLINT(readability-const-return-type)
@@ -172,6 +192,21 @@ private:
     friend class ContextPriv;
     friend class ContextCtorAccessor;
 
+    struct PixelTransferResult {
+        using ConversionFn = void(void* dst, const void* mappedBuffer);
+        // If null then the transfer could not be performed. Otherwise this buffer will contain
+        // the pixel data when the transfer is complete.
+        sk_sp<Buffer> fTransferBuffer;
+        // Size of the read.
+        SkISize fSize;
+        // RowBytes for transfer buffer data
+        size_t fRowBytes;
+        // If this is null then the transfer buffer will contain the data in the requested
+        // color type. Otherwise, when the transfer is done this must be called to convert
+        // from the transfer buffer's color type to the requested color type.
+        std::function<ConversionFn> fPixelConverter;
+    };
+
     SingleOwner* singleOwner() const { return &fSingleOwner; }
 
     // Must be called in Make() to handle one-time GPU setup operations that can possibly fail and
@@ -204,19 +239,11 @@ private:
                                SkImage::ReadPixelsCallback callback,
                                SkImage::ReadPixelsContext context);
 
+    void finalizeAsyncReadPixels(SkSpan<PixelTransferResult>,
+                                 SkImage::ReadPixelsCallback callback,
+                                 SkImage::ReadPixelsContext callbackContext);
+
     // Inserts a texture to buffer transfer task, used by asyncReadPixels methods
-    struct PixelTransferResult {
-        using ConversionFn = void(void* dst, const void* mappedBuffer);
-        // If null then the transfer could not be performed. Otherwise this buffer will contain
-        // the pixel data when the transfer is complete.
-        sk_sp<Buffer> fTransferBuffer;
-        // RowBytes for transfer buffer data
-        size_t fRowBytes;
-        // If this is null then the transfer buffer will contain the data in the requested
-        // color type. Otherwise, when the transfer is done this must be called to convert
-        // from the transfer buffer's color type to the requested color type.
-        std::function<ConversionFn> fPixelConverter;
-    };
     PixelTransferResult transferPixels(const TextureProxy*,
                                        const SkImageInfo& srcImageInfo,
                                        const SkColorInfo& dstColorInfo,
@@ -226,7 +253,6 @@ private:
     std::unique_ptr<ResourceProvider> fResourceProvider;
     std::unique_ptr<QueueManager> fQueueManager;
     std::unique_ptr<ClientMappedBufferManager> fMappedBufferManager;
-    std::unique_ptr<PlotUploadTracker> fPlotUploadTracker;
 
     // In debug builds we guard against improper thread handling. This guard is passed to the
     // ResourceCache for the Context.

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

@@ -80,6 +80,8 @@ struct SK_API ContextOptions {
     /**
      * Disable caching of glyph uploads at the start of each Recording. These can add additional
      * overhead and are only necessary if Recordings are replayed or played out of order.
+     *
+     * Deprecated, now only used to set requireOrderedRecordings Caps.
      */
     bool fDisableCachedGlyphUploads = false;
 

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

@@ -46,7 +46,8 @@ using GpuFinishedProc = void (*)(GpuFinishedContext finishedContext, CallbackRes
  *
  * The client may pass in two arrays of initialized BackendSemaphores to be included in the
  * command stream. At some time before issuing commands in the Recording, the fWaitSemaphores will
- * be waited on by the gpu. Similarly, at some time after issuing the Recording's commands, the
+ * be waited on by the gpu. We only guarantee these wait semaphores block transfer and fragment
+ * shader work. Similarly, at some time after issuing the Recording's commands, the
  * fSignalSemaphores will be signaled by the gpu. Depending on the platform, the timing of the wait
  * and signal operations will either be immediately before or after the given Recording's command
  * stream, respectively, or before and after the entire CommandBuffer's command stream. The

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