@shopify/react-native-skia 0.1.212 → 0.1.214

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

@@ -14,9 +14,6 @@
 #include "include/gpu/GrTypes.h"
 #include "include/private/base/SkAPI.h"
 
-// TODO(kjlubick) remove after chromium is migrated to include this directly
-#include "include/private/chromium/SkImageChromium.h"  // IWYU pragma: keep
-
 #include <functional>
 #include <utility>
 
@@ -26,6 +23,8 @@ class GrRecordingContext;
 class GrYUVABackendTextures;
 class SkColorSpace;
 class SkData;
+class SkImageFilter;
+struct SkIPoint;
 class SkPixmap;
 class SkYUVAPixmaps;
 enum SkAlphaType : int;
@@ -174,13 +173,14 @@ SK_API sk_sp<SkImage> TextureFromCompressedTexture(GrRecordingContext* context,
     @param isProtected do the contents of 'data' require DRM protection (on Vulkan)?
     @return            created SkImage, or nullptr
 */
-SK_API sk_sp<SkImage> TextureFromCompressedTextureData(GrDirectContext* direct,
-                                                       sk_sp<SkData> data,
-                                                       int width,
-                                                       int height,
-                                                       SkTextureCompressionType type,
-                                                       GrMipmapped mipmapped = GrMipmapped::kNo,
-                                                       GrProtected isProtected = GrProtected::kNo);
+SK_API sk_sp<SkImage> TextureFromCompressedTextureData(
+        GrDirectContext* direct,
+        sk_sp<SkData> data,
+        int width,
+        int height,
+        SkTextureCompressionType type,
+        skgpu::Mipmapped mipmapped = skgpu::Mipmapped::kNo,
+        GrProtected isProtected = GrProtected::kNo);
 
 /** Returns SkImage backed by GPU texture associated with context. Returned SkImage is
     compatible with SkSurface created with dstColorSpace. The returned SkImage respects
@@ -232,12 +232,12 @@ inline sk_sp<SkImage> TextureFromImage(GrDirectContext* ctx,
 */
 SK_API sk_sp<SkImage> TextureFromYUVAPixmaps(GrRecordingContext* context,
                                              const SkYUVAPixmaps& pixmaps,
-                                             GrMipmapped buildMips,
+                                             skgpu::Mipmapped buildMips,
                                              bool limitToMaxTextureSize,
                                              sk_sp<SkColorSpace> imageColorSpace);
 SK_API sk_sp<SkImage> TextureFromYUVAPixmaps(GrRecordingContext* context,
                                              const SkYUVAPixmaps& pixmaps,
-                                             GrMipmapped buildMips = GrMipmapped::kNo,
+                                             skgpu::Mipmapped buildMips = skgpu::Mipmapped::kNo,
                                              bool limitToMaxTextureSize = false);
 
 /** Creates a GPU-backed SkImage from YUV[A] planar textures. This requires that the textures
@@ -324,6 +324,38 @@ SK_API sk_sp<SkImage> SubsetTextureFrom(GrDirectContext* context,
                                         const SkImage* img,
                                         const SkIRect& subset);
 
+/** 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 or if the recording context provided doesn't
+    match the GPU context in which the image was 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 context     the GrRecordingContext in play - if it exists
+    @param filter      how SkImage is sampled when transformed
+    @param subset      bounds of SkImage processed by filter
+    @param clipBounds  expected bounds of filtered SkImage
+    @param outSubset   storage for returned SkImage bounds
+    @param offset      storage for returned SkImage translation
+    @return            filtered SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> MakeWithFilter(GrRecordingContext* context,
+                                     sk_sp<SkImage> src,
+                                     const SkImageFilter* filter,
+                                     const SkIRect& subset,
+                                     const SkIRect& clipBounds,
+                                     SkIRect* outSubset,
+                                     SkIPoint* offset);
+
 }  // namespace SkImages
 
 #endif

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

@@ -0,0 +1,57 @@
+/*
+ * 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 SkMeshGanesh_DEFINED
+#define SkMeshGanesh_DEFINED
+
+#include "include/core/SkMesh.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+#include <cstddef>
+
+class GrDirectContext;
+
+namespace SkMeshes {
+/**
+ * Makes a GPU-backed index buffer to be used with SkMeshes.
+ *
+ * @param  GrDirectContext*  If non-null, the data will be uploaded to the corresponding GPU and the
+ *                           returned buffer will only be compatible with surfaces using the same
+ *                           context. If null, the data will be uploaded to a CPU buffer.
+ * @param  data              The data used to populate the buffer, or nullptr to create a zero-
+ *                           initialized buffer.
+ * @param  size              Both the size of the data in 'data' and the size of the resulting
+ *                           buffer.
+ */
+SK_API sk_sp<SkMesh::IndexBuffer> MakeIndexBuffer(GrDirectContext*, const void* data, size_t size);
+
+/**
+ * Makes a copy of an index buffer. The copy will be GPU backed if the context is non-null.
+ */
+SK_API sk_sp<SkMesh::IndexBuffer> CopyIndexBuffer(GrDirectContext*, sk_sp<SkMesh::IndexBuffer>);
+
+/**
+ * Makes a GPU-backed vertex buffer to be used with SkMeshes.
+ *
+ * @param  GrDirectContext*  If non-null, the data will be uploaded to the corresponding GPU and the
+ *                           returned buffer will only be compatible with surfaces using the same
+ *                           context. If null, the data will be uploaded to a CPU buffer.
+ * @param  data              The data used to populate the buffer, or nullptr to create a zero-
+ *                           initialized buffer.
+ * @param  size              Both the size of the data in 'data' and the size of the resulting
+ *                           buffer.
+ */
+SK_API sk_sp<SkMesh::VertexBuffer> MakeVertexBuffer(GrDirectContext*, const void*, size_t size);
+
+/**
+ * Makes a copy of a vertex buffer. The copy will be GPU backed if the context is non-null.
+ */
+SK_API sk_sp<SkMesh::VertexBuffer> CopyVertexBuffer(GrDirectContext*, sk_sp<SkMesh::VertexBuffer>);
+}  // namespace SkMeshes
+
+#endif

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

@@ -67,7 +67,8 @@ SK_API sk_sp<SkSurface> RenderTarget(GrRecordingContext* context,
                                      int sampleCount,
                                      GrSurfaceOrigin surfaceOrigin,
                                      const SkSurfaceProps* surfaceProps,
-                                     bool shouldCreateWithMips = false);
+                                     bool shouldCreateWithMips = false,
+                                     bool isProtected = false);
 inline sk_sp<SkSurface> RenderTarget(GrRecordingContext* context,
                                      skgpu::Budgeted budgeted,
                                      const SkImageInfo& imageInfo,

package/cpp/skia/include/gpu/ganesh/gl/GrGLBackendSurface.h

@@ -0,0 +1,58 @@
+/*
+ * 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 GrGLBackendSurface_DEFINED
+#define GrGLBackendSurface_DEFINED
+
+#include "include/gpu/gl/GrGLTypes.h"
+#include "include/private/base/SkAPI.h"
+
+#include <string_view>
+
+class GrBackendFormat;
+class GrBackendTexture;
+class GrBackendRenderTarget;
+
+namespace skgpu { enum class Mipmapped : bool; }
+
+namespace GrBackendFormats {
+SK_API GrBackendFormat MakeGL(GrGLenum format, GrGLenum target);
+
+SK_API GrGLFormat AsGLFormat(const GrBackendFormat&);
+SK_API GrGLenum AsGLFormatEnum(const GrBackendFormat&);
+}  // namespace GrBackendFormats
+
+namespace GrBackendTextures {
+// The GrGLTextureInfo must have a valid fFormat.
+SK_API GrBackendTexture MakeGL(int width,
+                               int height,
+                               skgpu::Mipmapped,
+                               const GrGLTextureInfo& glInfo,
+                               std::string_view label = {});
+
+// If the backend API is GL, copies a snapshot of the GrGLTextureInfo struct into the passed in
+// pointer and returns true. Otherwise returns false if the backend API is not GL.
+SK_API bool GetGLTextureInfo(const GrBackendTexture&, GrGLTextureInfo*);
+
+// Call this to indicate that the texture parameters have been modified in the GL context
+// externally to GrContext.
+SK_API void GLTextureParametersModified(GrBackendTexture*);
+}  // namespace GrBackendTextures
+
+namespace GrBackendRenderTargets {
+// The GrGLTextureInfo must have a valid fFormat. If wrapping in an SkSurface we require the
+// stencil bits to be either 0, 8 or 16.
+SK_API GrBackendRenderTarget MakeGL(int width,
+                                    int height,
+                                    int sampleCnt,
+                                    int stencilBits,
+                                    const GrGLFramebufferInfo& glInfo);
+
+SK_API bool GetGLFramebufferInfo(const GrBackendRenderTarget&, GrGLFramebufferInfo*);
+}  // namespace GrBackendRenderTargets
+
+#endif

package/cpp/skia/include/gpu/ganesh/gl/GrGLDirectContext.h

@@ -0,0 +1,29 @@
+/*
+ * 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 GrGLDirectContext_DEFINED
+#define GrGLDirectContext_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+class GrDirectContext;
+struct GrContextOptions;
+struct GrGLInterface;
+
+namespace GrDirectContexts {
+/**
+ * Creates a GrDirectContext for a backend context. If no GrGLInterface is provided then the
+ * result of GrGLMakeNativeInterface() is used if it succeeds.
+ */
+SK_API sk_sp<GrDirectContext> MakeGL(sk_sp<const GrGLInterface>, const GrContextOptions&);
+SK_API sk_sp<GrDirectContext> MakeGL(sk_sp<const GrGLInterface>);
+SK_API sk_sp<GrDirectContext> MakeGL(const GrContextOptions&);
+SK_API sk_sp<GrDirectContext> MakeGL();
+}
+
+#endif

package/cpp/skia/include/gpu/ganesh/mtl/SkSurfaceMetal.h

@@ -67,7 +67,7 @@ SK_API sk_sp<SkSurface> WrapMTKView(GrRecordingContext* context,
                                     SkColorType colorType,
                                     sk_sp<SkColorSpace> colorSpace,
                                     const SkSurfaceProps* surfaceProps)
-        SK_API_AVAILABLE(macos(10.11), ios(9.0));
+        SK_API_AVAILABLE(macos(10.11), ios(9.0), tvos(9.0));
 }  // namespace SkSurfaces
 
 #endif

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

@@ -0,0 +1,67 @@
+/*
+ * 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 GrVkBackendSurface_DEFINED
+#define GrVkBackendSurface_DEFINED
+
+#include "include/gpu/vk/GrVkTypes.h"
+#include "include/private/base/SkAPI.h"
+
+#include <string_view>
+
+class GrBackendFormat;
+class GrBackendTexture;
+class GrBackendRenderTarget;
+
+
+namespace GrBackendFormats {
+
+SK_API GrBackendFormat MakeVk(VkFormat format, bool willUseDRMFormatModifiers = false);
+SK_API GrBackendFormat MakeVk(const GrVkYcbcrConversionInfo& ycbcrInfo,
+                              bool willUseDRMFormatModifiers = false);
+
+SK_API bool AsVkFormat(const GrBackendFormat&, VkFormat*);
+SK_API const GrVkYcbcrConversionInfo* GetVkYcbcrConversionInfo(const GrBackendFormat&);
+
+}  // namespace GrBackendFormats
+
+
+namespace GrBackendTextures {
+
+SK_API GrBackendTexture MakeVk(int width,
+                               int height,
+                               const GrVkImageInfo&,
+                               std::string_view label = {});
+
+// If the backend API is Vulkan, copies a snapshot of the GrVkImageInfo struct into the passed
+// in pointer and returns true. This snapshot will set the fImageLayout to the current layout
+// state. Otherwise returns false if the backend API is not Vulkan.
+SK_API bool GetVkImageInfo(const GrBackendTexture&, GrVkImageInfo*);
+
+// Anytime the client changes the VkImageLayout of the VkImage captured by this
+// GrBackendTexture, they must call this function to notify Skia of the changed layout.
+SK_API void SetVkImageLayout(GrBackendTexture*, VkImageLayout);
+
+}  // namespace GrBackendTextures
+
+
+namespace GrBackendRenderTargets {
+
+SK_API GrBackendRenderTarget MakeVk(int width, int height, const GrVkImageInfo&);
+
+// If the backend API is Vulkan, copies a snapshot of the GrVkImageInfo struct into the passed
+// in pointer and returns true. This snapshot will set the fImageLayout to the current layout
+// state. Otherwise returns false if the backend API is not Vulkan.
+SK_API bool GetVkImageInfo(const GrBackendRenderTarget&, GrVkImageInfo*);
+
+// Anytime the client changes the VkImageLayout of the VkImage captured by this
+// GrBackendRenderTarget, they must call this function to notify Skia of the changed layout.
+SK_API void SetVkImageLayout(GrBackendRenderTarget*, VkImageLayout);
+
+}  // namespace GrBackendRenderTargets
+
+#endif

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

@@ -68,7 +68,7 @@ public:
     void suppressErrorLogging();
 #endif
 
-#if GR_TEST_UTILS
+#if defined(GR_TEST_UTILS)
     GrGLInterface(const GrGLInterface& that)
             : fStandard(that.fStandard)
             , fExtensions(that.fExtensions)
@@ -331,7 +331,7 @@ public:
         GrGLFunction<GrGLEndTilingFn> fEndTiling;
     } fFunctions;
 
-#if GR_TEST_UTILS
+#if defined(GR_TEST_UTILS)
     // This exists for internal testing.
     virtual void abandon() const;
 #endif

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

@@ -22,6 +22,7 @@
 #endif
 
 #ifdef SK_VULKAN
+#include "include/gpu/vk/VulkanTypes.h"
 #include "include/private/gpu/vk/SkiaVulkan.h"
 #endif
 
@@ -70,7 +71,8 @@ public:
                    const VulkanTextureInfo&,
                    VkImageLayout,
                    uint32_t queueFamilyIndex,
-                   VkImage);
+                   VkImage,
+                   VulkanAlloc);
 #endif
 
     BackendTexture(const BackendTexture&);
@@ -108,16 +110,25 @@ public:
     VkImage getVkImage() const;
     VkImageLayout getVkImageLayout() const;
     uint32_t getVkQueueFamilyIndex() const;
+    const VulkanAlloc* getMemoryAlloc() const;
 #endif
 
 private:
-    sk_sp<MutableTextureStateRef> mutableState() const;
+    friend class VulkanResourceProvider;    // for getMutableState
+    sk_sp<MutableTextureStateRef> getMutableState() const;
 
     SkISize fDimensions;
     TextureInfo fInfo;
 
     sk_sp<MutableTextureStateRef> fMutableState;
 
+#ifdef SK_VULKAN
+    // fMemoryAlloc == VulkanAlloc() if the client has already created their own VkImage and
+    // will destroy it themselves as opposed to having Skia create/destroy it via
+    // Recorder::createBackendTexture and Context::deleteBackendTexture.
+    VulkanAlloc fMemoryAlloc = VulkanAlloc();
+#endif
+
     union {
 #ifdef SK_DAWN
         struct {
@@ -129,7 +140,7 @@ private:
         MtlHandle fMtlTexture;
 #endif
 #ifdef SK_VULKAN
-        VkImage fVkImage;
+        VkImage fVkImage = VK_NULL_HANDLE;
 #endif
         void* fEnsureUnionNonEmpty;
     };

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

@@ -16,9 +16,11 @@
 #include "include/gpu/graphite/Recorder.h"
 #include "include/private/base/SingleOwner.h"
 
+#include <chrono>
 #include <functional>
 #include <memory>
 
+class SkColorSpace;
 class SkRuntimeEffect;
 
 namespace skgpu::graphite {
@@ -53,17 +55,61 @@ public:
     bool insertRecording(const InsertRecordingInfo&);
     bool submit(SyncToCpu = SyncToCpu::kNo);
 
-    void asyncReadPixels(const SkImage* image,
-                         const SkColorInfo& dstColorInfo,
-                         const SkIRect& srcRect,
-                         SkImage::ReadPixelsCallback callback,
-                         SkImage::ReadPixelsContext context);
-
-    void asyncReadPixels(const SkSurface* surface,
-                         const SkColorInfo& dstColorInfo,
-                         const SkIRect& srcRect,
-                         SkImage::ReadPixelsCallback callback,
-                         SkImage::ReadPixelsContext context);
+    void asyncRescaleAndReadPixels(const SkImage* image,
+                                   const SkImageInfo& dstImageInfo,
+                                   const SkIRect& srcRect,
+                                   SkImage::RescaleGamma rescaleGamma,
+                                   SkImage::RescaleMode rescaleMode,
+                                   SkImage::ReadPixelsCallback callback,
+                                   SkImage::ReadPixelsContext context);
+
+    void asyncRescaleAndReadPixels(const SkSurface* surface,
+                                   const SkImageInfo& dstImageInfo,
+                                   const SkIRect& srcRect,
+                                   SkImage::RescaleGamma rescaleGamma,
+                                   SkImage::RescaleMode rescaleMode,
+                                   SkImage::ReadPixelsCallback callback,
+                                   SkImage::ReadPixelsContext context);
+
+    void asyncRescaleAndReadPixelsYUV420(const SkImage*,
+                                         SkYUVColorSpace yuvColorSpace,
+                                         sk_sp<SkColorSpace> dstColorSpace,
+                                         const SkIRect& srcRect,
+                                         const SkISize& dstSize,
+                                         SkImage::RescaleGamma rescaleGamma,
+                                         SkImage::RescaleMode rescaleMode,
+                                         SkImage::ReadPixelsCallback callback,
+                                         SkImage::ReadPixelsContext context);
+
+    void asyncRescaleAndReadPixelsYUV420(const SkSurface*,
+                                         SkYUVColorSpace yuvColorSpace,
+                                         sk_sp<SkColorSpace> dstColorSpace,
+                                         const SkIRect& srcRect,
+                                         const SkISize& dstSize,
+                                         SkImage::RescaleGamma rescaleGamma,
+                                         SkImage::RescaleMode rescaleMode,
+                                         SkImage::ReadPixelsCallback callback,
+                                         SkImage::ReadPixelsContext context);
+
+    void asyncRescaleAndReadPixelsYUVA420(const SkImage*,
+                                          SkYUVColorSpace yuvColorSpace,
+                                          sk_sp<SkColorSpace> dstColorSpace,
+                                          const SkIRect& srcRect,
+                                          const SkISize& dstSize,
+                                          SkImage::RescaleGamma rescaleGamma,
+                                          SkImage::RescaleMode rescaleMode,
+                                          SkImage::ReadPixelsCallback callback,
+                                          SkImage::ReadPixelsContext context);
+
+    void asyncRescaleAndReadPixelsYUVA420(const SkSurface*,
+                                          SkYUVColorSpace yuvColorSpace,
+                                          sk_sp<SkColorSpace> dstColorSpace,
+                                          const SkIRect& srcRect,
+                                          const SkISize& dstSize,
+                                          SkImage::RescaleGamma rescaleGamma,
+                                          SkImage::RescaleMode rescaleMode,
+                                          SkImage::ReadPixelsCallback callback,
+                                          SkImage::ReadPixelsContext context);
 
     /**
      * Checks whether any asynchronous work is complete and if so calls related callbacks.
@@ -79,7 +125,22 @@ public:
      * Otherwise this will delete/release the backend object that is wrapped in the BackendTexture.
      * The BackendTexture will be reset to an invalid state and should not be used again.
      */
-    void deleteBackendTexture(BackendTexture&);
+    void deleteBackendTexture(const BackendTexture&);
+
+    /**
+     * Frees GPU resources created and held by the Context. Can be called to reduce GPU memory
+     * pressure. Any resources that are still in use (e.g. being used by work submitted to the GPU)
+     * will not be deleted by this call. If the caller wants to make sure all resources are freed,
+     * then they should first make sure to submit and wait on any outstanding work.
+     */
+    void freeGpuResources();
+
+    /**
+     * Purge GPU resources on the Context that haven't been used in the past 'msNotUsed'
+     * milliseconds or are otherwise marked for deletion, regardless of whether the context is under
+     * budget.
+     */
+    void performDeferredCleanup(std::chrono::milliseconds msNotUsed);
 
     // Provides access to functions that aren't part of the public API.
     ContextPriv priv();
@@ -117,6 +178,17 @@ private:
     // require Context::Make() to return a nullptr.
     bool finishInitialization();
 
+    void asyncRescaleAndReadPixelsYUV420Impl(const SkImage*,
+                                             SkYUVColorSpace yuvColorSpace,
+                                             bool readAlpha,
+                                             sk_sp<SkColorSpace> dstColorSpace,
+                                             const SkIRect& srcRect,
+                                             const SkISize& dstSize,
+                                             SkImage::RescaleGamma rescaleGamma,
+                                             SkImage::RescaleMode rescaleMode,
+                                             SkImage::ReadPixelsCallback callback,
+                                             SkImage::ReadPixelsContext context);
+
     void asyncReadPixels(const TextureProxy* textureProxy,
                          const SkImageInfo& srcImageInfo,
                          const SkColorInfo& dstColorInfo,
@@ -124,6 +196,14 @@ private:
                          SkImage::ReadPixelsCallback callback,
                          SkImage::ReadPixelsContext context);
 
+    void asyncReadPixelsYUV420(Recorder*,
+                               const SkImage*,
+                               SkYUVColorSpace yuvColorSpace,
+                               bool readAlpha,
+                               const SkIRect& srcRect,
+                               SkImage::ReadPixelsCallback callback,
+                               SkImage::ReadPixelsContext context);
+
     // Inserts a texture to buffer transfer task, used by asyncReadPixels methods
     struct PixelTransferResult {
         using ConversionFn = void(void* dst, const void* mappedBuffer);
@@ -152,7 +232,7 @@ private:
     // ResourceCache for the Context.
     mutable SingleOwner fSingleOwner;
 
-#if GRAPHITE_TEST_UTILS
+#if defined(GRAPHITE_TEST_UTILS)
     // In test builds a Recorder may track the Context that was used to create it.
     bool fStoreContextRefInRecorder = false;
     // If this tracking is on, to allow the client to safely delete this Context or its Recorders

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

@@ -9,11 +9,14 @@
 #define skgpu_graphite_ContextOptions_DEFINED
 
 #include "include/private/base/SkAPI.h"
+#include "include/private/base/SkMath.h"
 
 namespace skgpu { class ShaderErrorHandler; }
 
 namespace skgpu::graphite {
 
+struct ContextOptionsPriv;
+
 struct SK_API ContextOptions {
     ContextOptions() {}
 
@@ -30,6 +33,14 @@ struct SK_API ContextOptions {
      */
     skgpu::ShaderErrorHandler* fShaderErrorHandler = nullptr;
 
+    /**
+     * Specifies the number of samples Graphite should use when performing internal draws with MSAA
+     * (hardware capabilities permitting).
+     *
+     * If <= 1, Graphite will disable internal code paths that use multisampling.
+     */
+    int fInternalMultisampleCount = 4;
+
     /**
      * Will the client make sure to only ever be executing one thread that uses the Context and all
      * derived classes (e.g. Recorders, Recordings, etc.) at a time. If so we can possibly make some
@@ -66,22 +77,22 @@ struct SK_API ContextOptions {
     bool fAllowMultipleGlyphCacheTextures = true;
     bool fSupportBilerpFromGlyphAtlas = false;
 
-#if GRAPHITE_TEST_UTILS
     /**
-     * Private options that are only meant for testing within Skia's tools.
+     * 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.
      */
+    bool fDisableCachedGlyphUploads = false;
 
+    static constexpr size_t kDefaultContextBudget = 256 * (1 << 20);
     /**
-     * Maximum width and height of internal texture atlases.
+     * What is the budget for GPU resources allocated and held by the Context.
      */
-    int  fMaxTextureAtlasSize = 2048;
+    size_t fGpuBudgetInBytes = kDefaultContextBudget;
 
     /**
-     * If true, will store a pointer in Recorder that points back to the Context
-     * that created it. Used by readPixels() and other methods that normally require a Context.
+     * Private options that are only meant for testing within Skia's tools.
      */
-    bool fStoreContextRefInRecorder = false;
-#endif
+    ContextOptionsPriv* fOptionsPriv = nullptr;
 };
 
 }  // namespace skgpu::graphite

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

@@ -16,8 +16,13 @@
 
 class SkSurface;
 
+namespace skgpu {
+class MutableTextureState;
+}
+
 namespace skgpu::graphite {
 
+class BackendSemaphore;
 class Recording;
 class Task;
 
@@ -38,12 +43,30 @@ using GpuFinishedProc = void (*)(GpuFinishedContext finishedContext, CallbackRes
  * TextureInfo must match the info provided to the Recorder when making the deferred canvas.
  *
  * fTargetTranslation is an additional translation applied to draws targeting fTargetSurface.
+ *
+ * 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
+ * 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
+ * semaphores are not sent to the GPU until the next Context::submit call is made.
+ *
+ * The client will own and be responsible for deleting the underlying semaphore objects after the
+ * submission completes, however the BackendSemaphore objects themselves can be deleted as soon
+ * as this function returns.
  */
 struct InsertRecordingInfo {
     Recording* fRecording = nullptr;
 
     SkSurface* fTargetSurface = nullptr;
     SkIVector fTargetTranslation = {0, 0};
+    MutableTextureState* fTargetTextureState = nullptr;
+
+    size_t fNumWaitSemaphores = 0;
+    BackendSemaphore* fWaitSemaphores = nullptr;
+    size_t fNumSignalSemaphores = 0;
+    BackendSemaphore* fSignalSemaphores = nullptr;
 
     GpuFinishedContext fFinishedContext = nullptr;
     GpuFinishedProc fFinishedProc = nullptr;