@shopify/react-native-skia 0.1.234 → 0.1.237

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

@@ -16,7 +16,6 @@
 class GrBackendSemaphore;
 
 namespace skgpu {
-enum class Mipmapped : bool;
 enum class Protected : bool;
 enum class Renderable : bool;
 }
@@ -129,14 +128,6 @@ static constexpr GrBackendApi kMock_GrBackend = GrBackendApi::kMock;
 
 ///////////////////////////////////////////////////////////////////////////////
 
-/**
- * Used to say whether a texture has mip levels allocated or not.
- */
-/** Deprecated legacy alias of skgpu::Mipmapped. */
-using GrMipmapped = skgpu::Mipmapped;
-/** Deprecated legacy alias of skgpu::Mipmapped. */
-using GrMipMapped = skgpu::Mipmapped;
-
 /*
  * Can a GrBackendObject be rendered to?
  */
@@ -220,13 +211,7 @@ typedef void (*GrDirectContextDestroyedProc)(GrDirectContextDestroyedContext des
  * The submittedProc is useful to the client to know when semaphores that were sent with the flush
  * have actually been submitted to the GPU so that they can be waited on (or deleted if the submit
  * fails).
- * Note about GL: In GL work gets sent to the driver immediately during the flush call, but we don't
- * really know when the driver sends the work to the GPU. Therefore, we treat the submitted proc as
- * we do in other backends. It will be called when the next GrContext::submit is called after the
- * flush (or possibly during the flush if there is no work to be done for the flush). The main use
- * case for the submittedProc is to know when semaphores have been sent to the GPU and even in GL
- * it is required to call GrContext::submit to flush them. So a client should be able to treat all
- * backend APIs the same in terms of how the submitted procs are treated.
+ * GrBackendSemaphores are not supported for the GL backend and will be ignored if set.
  */
 struct GrFlushInfo {
     size_t fNumSemaphores = 0;

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

@@ -8,21 +8,21 @@
 #ifndef skgpu_MutableTextureState_DEFINED
 #define skgpu_MutableTextureState_DEFINED
 
+#include "include/core/SkRefCnt.h"
 #include "include/core/SkTypes.h"
-#include "include/gpu/GpuTypes.h"
+#include "include/private/base/SkAnySubclass.h"
 
-#ifdef SK_VULKAN
+#if defined(SK_VULKAN) && !defined(SK_DISABLE_LEGACY_VULKAN_MUTABLE_TEXTURE_STATE)
 #include "include/private/gpu/vk/SkiaVulkan.h"
-#include "include/private/gpu/vk/VulkanTypesPriv.h"
 
 #include <cstdint>
 #endif
 
-#include <new>
-
-class GrVkGpu;
+#include <cstddef>
 
 namespace skgpu {
+enum class BackendApi : unsigned int;
+class MutableTextureStateData;
 
 /**
  * Since Skia and clients can both modify gpu textures and their connected state, Skia needs a way
@@ -30,95 +30,50 @@ namespace skgpu {
  * for every single API and state, we use this class to be a generic wrapper around all the mutable
  * state. This class is used for calls that inform Skia of these texture/image state changes by the
  * client as well as for requesting state changes to be done by Skia. The backend specific state
- * that is wrapped by this class are:
- *
- * Vulkan: VkImageLayout and QueueFamilyIndex
+ * that is wrapped by this class are located in files like:
+ *   - include/gpu/vk/VulkanMutableTextureState.h
  */
-class SK_API MutableTextureState {
+class SK_API MutableTextureState : public SkRefCnt {
 public:
-    MutableTextureState() {}
-
-#ifdef SK_VULKAN
-    MutableTextureState(VkImageLayout layout, uint32_t queueFamilyIndex)
-            : fVkState(layout, queueFamilyIndex)
-            , fBackend(BackendApi::kVulkan)
-            , fIsValid(true) {}
-#endif
+    MutableTextureState();
+    ~MutableTextureState() override;
 
-    MutableTextureState(const MutableTextureState& that)
-            : fBackend(that.fBackend), fIsValid(that.fIsValid) {
-        if (!fIsValid) {
-            return;
-        }
-        switch (fBackend) {
-            case BackendApi::kVulkan:
-    #ifdef SK_VULKAN
-                SkASSERT(that.fBackend == BackendApi::kVulkan);
-                fVkState = that.fVkState;
-    #endif
-                break;
-            default:
-                (void)that;
-                SkUNREACHABLE;
-        }
-    }
+    MutableTextureState(const MutableTextureState& that);
 
-    MutableTextureState& operator=(const MutableTextureState& that) {
-        if (this != &that) {
-            this->~MutableTextureState();
-            new (this) MutableTextureState(that);
-        }
-        return *this;
-    }
+    MutableTextureState& operator=(const MutableTextureState& that);
 
-#ifdef SK_VULKAN
-    // If this class is not Vulkan backed it will return value of VK_IMAGE_LAYOUT_UNDEFINED.
-    // Otherwise it will return the VkImageLayout.
-    VkImageLayout getVkImageLayout() const {
-        if (this->isValid() && fBackend != BackendApi::kVulkan) {
-            return VK_IMAGE_LAYOUT_UNDEFINED;
-        }
-        return fVkState.getImageLayout();
-    }
-
-    // If this class is not Vulkan backed it will return value of VK_QUEUE_FAMILY_IGNORED.
-    // Otherwise it will return the VkImageLayout.
-    uint32_t getQueueFamilyIndex() const {
-        if (this->isValid() && fBackend != BackendApi::kVulkan) {
-            return VK_QUEUE_FAMILY_IGNORED;
-        }
-        return fVkState.getQueueFamilyIndex();
-    }
-#endif
+    void set(const MutableTextureState& that);
 
     BackendApi backend() const { return fBackend; }
 
     // Returns true if the backend mutable state has been initialized.
     bool isValid() const { return fIsValid; }
 
+#if defined(SK_VULKAN) && !defined(SK_DISABLE_LEGACY_VULKAN_MUTABLE_TEXTURE_STATE)
+    MutableTextureState(VkImageLayout layout, uint32_t queueFamilyIndex);
+
+    VkImageLayout getVkImageLayout() const;
+    uint32_t getQueueFamilyIndex() const;
+#endif
+
 private:
-    friend class MutableTextureStateRef;
-    friend class ::GrVkGpu;
-
-#ifdef SK_VULKAN
-    void setVulkanState(VkImageLayout layout, uint32_t queueFamilyIndex) {
-        SkASSERT(!this->isValid() || fBackend == BackendApi::kVulkan);
-        fVkState.setImageLayout(layout);
-        fVkState.setQueueFamilyIndex(queueFamilyIndex);
-        fBackend = BackendApi::kVulkan;
-        fIsValid = true;
+    friend class MutableTextureStateData;
+    friend class MutableTextureStatePriv;
+    // Size determined by looking at the MutableTextureStateData subclasses, then
+    // guessing-and-checking. Compiler will complain if this is too small - in that case,
+    // just increase the number.
+    inline constexpr static size_t kMaxSubclassSize = 16;
+    using AnyStateData = SkAnySubclass<MutableTextureStateData, kMaxSubclassSize>;
+
+    template <typename StateData>
+    MutableTextureState(BackendApi api, const StateData& data) : fBackend(api), fIsValid(true) {
+        fStateData.emplace<StateData>(data);
     }
-#endif
 
-    union {
-        char fPlaceholder;
-#ifdef SK_VULKAN
-        VulkanMutableTextureState fVkState;
-#endif
-    };
+    AnyStateData fStateData;
 
-    BackendApi fBackend = BackendApi::kMock;
-    bool fIsValid = false;
+    BackendApi fBackend;
+    bool fIsValid;
 };
 
 } // namespace skgpu

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

@@ -18,7 +18,17 @@ class SK_API ShaderErrorHandler {
 public:
     virtual ~ShaderErrorHandler() = default;
 
-    virtual void compileError(const char* shader, const char* errors) = 0;
+    /**
+     * compileError(shader, errors) is kept for backward compatibility with older clients.
+     */
+    virtual void compileError([[maybe_unused]] const char* shader,
+                              [[maybe_unused]] const char* errors) {}
+    virtual void compileError(const char* shader,
+                              const char* errors,
+                              [[maybe_unused]] bool shaderWasCached) {
+        // Default implementation. Ignore shaderWasCached.
+        this->compileError(shader, errors);
+    }
 
 protected:
     ShaderErrorHandler() = default;

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

@@ -206,7 +206,7 @@ SK_API sk_sp<SkImage> TextureFromImage(GrDirectContext*,
                                        skgpu::Mipmapped = skgpu::Mipmapped::kNo,
                                        skgpu::Budgeted = skgpu::Budgeted::kYes);
 inline sk_sp<SkImage> TextureFromImage(GrDirectContext* ctx,
-                                       sk_sp<const SkImage> img,
+                                       const sk_sp<const SkImage>& img,
                                        skgpu::Mipmapped m = skgpu::Mipmapped::kNo,
                                        skgpu::Budgeted b = skgpu::Budgeted::kYes) {
     return TextureFromImage(ctx, img.get(), m, b);
@@ -276,7 +276,7 @@ SK_API bool GetBackendTextureFromImage(const SkImage* img,
                                        GrBackendTexture* outTexture,
                                        bool flushPendingGrContextIO,
                                        GrSurfaceOrigin* origin = nullptr);
-inline bool GetBackendTextureFromImage(sk_sp<const SkImage> img,
+inline bool GetBackendTextureFromImage(const sk_sp<const SkImage>& img,
                                        GrBackendTexture* outTexture,
                                        bool flushPendingGrContextIO,
                                        GrSurfaceOrigin* origin = nullptr) {

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

@@ -199,7 +199,7 @@ SK_API GrBackendRenderTarget GetBackendRenderTarget(SkSurface*, BackendHandleAcc
     GrDirectContext::flush.
  */
 SK_API void ResolveMSAA(SkSurface* surface);
-inline void ResolveMSAA(sk_sp<SkSurface> surface) {
+inline void ResolveMSAA(const sk_sp<SkSurface>& surface) {
     return ResolveMSAA(surface.get());
 }
 

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

@@ -17,13 +17,14 @@ 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.
+ * Creates a GrDirectContext for a backend context. GrGLInterface must be non-null.
  */
 SK_API sk_sp<GrDirectContext> MakeGL(sk_sp<const GrGLInterface>, const GrContextOptions&);
 SK_API sk_sp<GrDirectContext> MakeGL(sk_sp<const GrGLInterface>);
+#if !defined(SK_DISABLE_LEGACY_GL_MAKE_NATIVE_INTERFACE)
 SK_API sk_sp<GrDirectContext> MakeGL(const GrContextOptions&);
 SK_API sk_sp<GrDirectContext> MakeGL();
+#endif
 }
 
 #endif

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

@@ -0,0 +1,20 @@
+/*
+ * 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 GrVkBackendSemaphore_DEFINED
+#define GrVkBackendSemaphore_DEFINED
+
+#include "include/gpu/GrBackendSemaphore.h"
+#include "include/private/base/SkAPI.h"
+#include "include/private/gpu/vk/SkiaVulkan.h"
+
+namespace GrBackendSemaphores {
+SK_API GrBackendSemaphore MakeVk(VkSemaphore semaphore);
+SK_API VkSemaphore GetVkSemaphore(const GrBackendSemaphore&);
+}  // namespace GrBackendSemaphores
+
+#endif

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