@shopify/react-native-skia 1.11.9-next.1 → 1.11.10

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

@@ -75,55 +75,8 @@ struct SK_API GrContextOptions {
 
     GrContextOptions() {}
 
-    /**
-     * If Skia is creating a default VMA allocator for the Vulkan backend this value will be used
-     * for the preferredLargeHeapBlockSize. If the value is not set, then Skia will use an
-     * inernally defined default size.
-     *
-     * However, it is highly discouraged to have Skia make a default allocator (and support for
-     * doing so will be removed soon,  b/321962001). Instead clients should create their own
-     * allocator to pass into Skia where they can fine tune this value themeselves.
-     */
-    std::optional<uint64_t> fVulkanVMALargeHeapBlockSize;
-
-    /**
-     * Optional callback that can be passed into the GrDirectContext which will be called when the
-     * GrDirectContext is about to be destroyed. When this call is made, it will be safe for the
-     * client to delete the GPU backend context that is backing the GrDirectContext. The
-     * GrDirectContextDestroyedContext will be passed back to the client in the callback.
-     */
-    GrDirectContextDestroyedContext fContextDeleteContext = nullptr;
-    GrDirectContextDestroyedProc fContextDeleteProc = nullptr;
-
-    /**
-     * Executor to handle threaded work within Ganesh. If this is nullptr, then all work will be
-     * done serially on the main thread. To have worker threads assist with various tasks, set this
-     * to a valid SkExecutor instance. Currently, used for software path rendering, but may be used
-     * for other tasks.
-     */
-    SkExecutor* fExecutor = nullptr;
-
-    /**
-     * Cache in which to store compiled shader binaries between runs.
-     */
-    PersistentCache* fPersistentCache = nullptr;
-
-    /**
-     * If present, use this object to report shader compilation failures. If not, report failures
-     * via SkDebugf and assert.
-     */
-    ShaderErrorHandler* fShaderErrorHandler = nullptr;
-
-    /** Default minimum size to use when allocating buffers for uploading data to textures. The
-        larger the value the more uploads can be packed into one buffer, but at the cost of
-        more gpu memory allocated that may not be used. Uploads larger than the minimum will still
-        work by allocating a dedicated buffer. */
-    size_t fMinimumStagingBufferSize = 64 * 1024;
-
-    /**
-     * The maximum size of cache textures used for Skia's Glyph cache.
-     */
-    size_t fGlyphCacheTextureMaximumBytes = 2048 * 1024 * 4;
+    // Suppress prints for the GrContext.
+    bool fSuppressPrints = false;
 
     /**
      * Controls whether we check for GL errors after functions that allocate resources (e.g.
@@ -133,33 +86,6 @@ struct SK_API GrContextOptions {
      */
     Enable fSkipGLErrorChecks = Enable::kDefault;
 
-    /**
-     * Can the glyph atlas use multiple textures. If allowed, the each texture's size is bound by
-     * fGlypheCacheTextureMaximumBytes.
-     */
-    Enable fAllowMultipleGlyphCacheTextures = Enable::kDefault;
-
-    /**
-     * Enables driver workaround to use draws instead of HW clears, e.g. glClear on the GL backend.
-     */
-    Enable fUseDrawInsteadOfClear = Enable::kDefault;
-
-    /**
-     * Allow Ganesh to more aggressively reorder operations to reduce the number of render passes.
-     * Offscreen draws will be done upfront instead of interrupting the main render pass when
-     * possible. May increase VRAM usage, but still observes the resource cache limit.
-     * Enabled by default.
-     */
-    Enable fReduceOpsTaskSplitting = Enable::kDefault;
-
-    /**
-     * This affects the usage of the PersistentCache. We can cache SkSL, backend source (GLSL), or
-     * backend binaries (GL program binaries). By default we cache binaries, but if the driver's
-     * binary loading/storing is believed to have bugs, this can be limited to caching GLSL.
-     * Caching GLSL strings still saves CPU work when a GL program is created.
-     */
-    ShaderCacheStrategy fShaderCacheStrategy = ShaderCacheStrategy::kBackendBinary;
-
     /** Overrides: These options override feature detection using backend API queries. These
         overrides can only reduce the feature set or limits, never increase them beyond the
         detected values. */
@@ -171,48 +97,19 @@ struct SK_API GrContextOptions {
         deduce the optimal value for this platform. */
     int  fBufferMapThreshold = -1;
 
-    /**
-     * Maximum number of GPU programs or pipelines to keep active in the runtime cache.
-     */
-    int fRuntimeProgramCacheSize = 256;
-
-    /**
-     * Specifies the number of samples Ganesh should use when performing internal draws with MSAA
-     * (hardware capabilities permitting).
-     *
-     * If 0, Ganesh will disable internal code paths that use multisampling.
-     */
-    int  fInternalMultisampleCount = 4;
-
-    /**
-     * In Skia's vulkan backend a single GrContext submit equates to the submission of a single
-     * primary command buffer to the VkQueue. This value specifies how many vulkan secondary command
-     * buffers we will cache for reuse on a given primary command buffer. A single submit may use
-     * more than this many secondary command buffers, but after the primary command buffer is
-     * finished on the GPU it will only hold on to this many secondary command buffers for reuse.
-     *
-     * A value of -1 means we will pick a limit value internally.
-     */
-    int fMaxCachedVulkanSecondaryCommandBuffers = -1;
-
-    /**
-     * Below this threshold size in device space distance field fonts won't be used. Distance field
-     * fonts don't support hinting which is more important at smaller sizes.
-     */
-    float fMinDistanceFieldFontSize = 18;
+    /** Default minimum size to use when allocating buffers for uploading data to textures. The
+        larger the value the more uploads can be packed into one buffer, but at the cost of
+        more gpu memory allocated that may not be used. Uploads larger than the minimum will still
+        work by allocating a dedicated buffer. */
+    size_t fMinimumStagingBufferSize = 64 * 1024;
 
     /**
-     * Above this threshold size in device space glyphs are drawn as individual paths.
+     * Executor to handle threaded work within Ganesh. If this is nullptr, then all work will be
+     * done serially on the main thread. To have worker threads assist with various tasks, set this
+     * to a valid SkExecutor instance. Currently, used for software path rendering, but may be used
+     * for other tasks.
      */
-#if defined(SK_BUILD_FOR_ANDROID)
-    float fGlyphsAsPathsFontSize = 384;
-#elif defined(SK_BUILD_FOR_MAC)
-    float fGlyphsAsPathsFontSize = 256;
-#else
-    float fGlyphsAsPathsFontSize = 324;
-#endif
-
-    GrDriverBugWorkarounds fDriverBugWorkarounds;
+    SkExecutor* fExecutor = nullptr;
 
     /** Construct mipmaps manually, via repeated downsampling draw-calls. This is used when
         the driver's implementation (glGenerateMipmap) contains bugs. This requires mipmap
@@ -245,6 +142,34 @@ struct SK_API GrContextOptions {
      */
     bool fDisableGpuYUVConversion = false;
 
+    /**
+     * The maximum size of cache textures used for Skia's Glyph cache.
+     */
+    size_t fGlyphCacheTextureMaximumBytes = 2048 * 1024 * 4;
+
+    /**
+     * Below this threshold size in device space distance field fonts won't be used. Distance field
+     * fonts don't support hinting which is more important at smaller sizes.
+     */
+    float fMinDistanceFieldFontSize = 18;
+
+    /**
+     * Above this threshold size in device space glyphs are drawn as individual paths.
+     */
+#if defined(SK_BUILD_FOR_ANDROID)
+    float fGlyphsAsPathsFontSize = 384;
+#elif defined(SK_BUILD_FOR_MAC)
+    float fGlyphsAsPathsFontSize = 256;
+#else
+    float fGlyphsAsPathsFontSize = 324;
+#endif
+
+    /**
+     * Can the glyph atlas use multiple textures. If allowed, the each texture's size is bound by
+     * fGlypheCacheTextureMaximumBytes.
+     */
+    Enable fAllowMultipleGlyphCacheTextures = Enable::kDefault;
+
     /**
      * Bugs on certain drivers cause stencil buffers to leak. This flag causes Skia to avoid
      * allocating stencil buffers and use alternate rasterization paths, avoiding the leak.
@@ -258,6 +183,19 @@ struct SK_API GrContextOptions {
      */
     bool fSharpenMipmappedTextures = true;
 
+    /**
+     * Enables driver workaround to use draws instead of HW clears, e.g. glClear on the GL backend.
+     */
+    Enable fUseDrawInsteadOfClear = Enable::kDefault;
+
+    /**
+     * Allow Ganesh to more aggressively reorder operations to reduce the number of render passes.
+     * Offscreen draws will be done upfront instead of interrupting the main render pass when
+     * possible. May increase VRAM usage, but still observes the resource cache limit.
+     * Enabled by default.
+     */
+    Enable fReduceOpsTaskSplitting = Enable::kDefault;
+
     /**
      * Some ES3 contexts report the ES2 external image extension, but not the ES3 version.
      * If support for external images is critical, enabling this option will cause Ganesh to limit
@@ -272,6 +210,60 @@ struct SK_API GrContextOptions {
      */
     bool fDisableDriverCorrectnessWorkarounds = false;
 
+    /**
+     * Maximum number of GPU programs or pipelines to keep active in the runtime cache.
+     */
+    int fRuntimeProgramCacheSize = 256;
+
+    /**
+     * Cache in which to store compiled shader binaries between runs.
+     */
+    PersistentCache* fPersistentCache = nullptr;
+
+    /**
+     * This affects the usage of the PersistentCache. We can cache SkSL, backend source (GLSL), or
+     * backend binaries (GL program binaries). By default we cache binaries, but if the driver's
+     * binary loading/storing is believed to have bugs, this can be limited to caching GLSL.
+     * Caching GLSL strings still saves CPU work when a GL program is created.
+     */
+    ShaderCacheStrategy fShaderCacheStrategy = ShaderCacheStrategy::kBackendBinary;
+
+    /**
+     * If present, use this object to report shader compilation failures. If not, report failures
+     * via SkDebugf and assert.
+     */
+    ShaderErrorHandler* fShaderErrorHandler = nullptr;
+
+    /**
+     * Specifies the number of samples Ganesh should use when performing internal draws with MSAA
+     * (hardware capabilities permitting).
+     *
+     * If 0, Ganesh will disable internal code paths that use multisampling.
+     */
+    int  fInternalMultisampleCount = 4;
+
+    /**
+     * In Skia's vulkan backend a single GrContext submit equates to the submission of a single
+     * primary command buffer to the VkQueue. This value specifies how many vulkan secondary command
+     * buffers we will cache for reuse on a given primary command buffer. A single submit may use
+     * more than this many secondary command buffers, but after the primary command buffer is
+     * finished on the GPU it will only hold on to this many secondary command buffers for reuse.
+     *
+     * A value of -1 means we will pick a limit value internally.
+     */
+    int fMaxCachedVulkanSecondaryCommandBuffers = -1;
+
+    /**
+     * If Skia is creating a default VMA allocator for the Vulkan backend this value will be used
+     * for the preferredLargeHeapBlockSize. If the value is not set, then Skia will use an
+     * inernally defined default size.
+     *
+     * However, it is highly discouraged to have Skia make a default allocator (and support for
+     * doing so will be removed soon,  b/321962001). Instead clients should create their own
+     * allocator to pass into Skia where they can fine tune this value themeselves.
+     */
+    std::optional<uint64_t> fVulkanVMALargeHeapBlockSize;
+
     /**
      * If true, the caps will never support mipmaps.
      */
@@ -315,31 +307,19 @@ struct SK_API GrContextOptions {
      */
     bool fAlwaysUseTexStorageWhenAvailable = false;
 
-    // Suppress prints for the GrContext.
-    bool fSuppressPrints = false;
-
-#if defined(GPU_TEST_UTILS)
-    /**
-     * Private options that are only meant for testing within Skia's tools.
-     */
-
-    /**
-     * Include or exclude specific GPU path renderers.
-     */
-    GpuPathRenderers fGpuPathRenderers = GpuPathRenderers::kDefault;
-
     /**
-     * Specify the GPU resource cache limit. Equivalent to calling `setResourceCacheLimit` on the
-     * context at construction time.
-     *
-     * A value of -1 means use the default limit value.
+     * Optional callback that can be passed into the GrDirectContext which will be called when the
+     * GrDirectContext is about to be destroyed. When this call is made, it will be safe for the
+     * client to delete the GPU backend context that is backing the GrDirectContext. The
+     * GrDirectContextDestroyedContext will be passed back to the client in the callback.
      */
-    int fResourceCacheLimitOverride = -1;
+    GrDirectContextDestroyedContext fContextDeleteContext = nullptr;
+    GrDirectContextDestroyedProc fContextDeleteProc = nullptr;
 
+#if defined(GPU_TEST_UTILS)
     /**
-     * Maximum width and height of internal texture atlases.
+     * Private options that are only meant for testing within Skia's tools.
      */
-    int  fMaxTextureAtlasSize = 2048;
 
     /**
      * Testing-only mode to exercise allocation failures in the flush-time callback objects.
@@ -388,8 +368,26 @@ struct SK_API GrContextOptions {
      */
     bool fDisallowWriteAndTransferPixelRowBytes = false;
 
+    /**
+     * Include or exclude specific GPU path renderers.
+     */
+    GpuPathRenderers fGpuPathRenderers = GpuPathRenderers::kDefault;
+
+    /**
+     * Specify the GPU resource cache limit. Equivalent to calling `setResourceCacheLimit` on the
+     * context at construction time.
+     *
+     * A value of -1 means use the default limit value.
+     */
+    int fResourceCacheLimitOverride = -1;
+
+    /**
+     * Maximum width and height of internal texture atlases.
+     */
+    int  fMaxTextureAtlasSize = 2048;
 #endif
 
+    GrDriverBugWorkarounds fDriverBugWorkarounds;
 };
 
 #endif

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

@@ -271,11 +271,6 @@ public:
      */
     void purgeUnlockedResources(GrPurgeResourceOptions opts);
 
-    /*
-     * Gets the types of GPU stats supported by this Context.
-     */
-    skgpu::GpuStatsFlags supportedGpuStats() const;
-
     /**
      * Gets the maximum supported texture size.
      */

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

@@ -34,10 +34,8 @@ enum GrDriverBugWorkaroundType {
 
 class SK_API GrDriverBugWorkarounds {
  public:
-  GrDriverBugWorkarounds() = default;
+  GrDriverBugWorkarounds();
   GrDriverBugWorkarounds(const GrDriverBugWorkarounds&) = default;
-  ~GrDriverBugWorkarounds() = default;
-
   explicit GrDriverBugWorkarounds(const std::vector<int32_t>& workarounds);
 
   GrDriverBugWorkarounds& operator=(const GrDriverBugWorkarounds&) = default;
@@ -45,6 +43,8 @@ class SK_API GrDriverBugWorkarounds {
   // Turn on any workarounds listed in |workarounds| (but don't turn any off).
   void applyOverrides(const GrDriverBugWorkarounds& workarounds);
 
+  ~GrDriverBugWorkarounds();
+
 #define GPU_OP(type, name) bool name = false;
   GPU_DRIVER_BUG_WORKAROUNDS(GPU_OP)
 #undef GPU_OP

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

@@ -9,13 +9,17 @@
 #define GrTypes_DEFINED
 
 #include "include/core/SkTypes.h"
-#include "include/gpu/GpuTypes.h"
 #include "include/private/base/SkTo.h" // IWYU pragma: keep
 
 #include <cstddef>
 #include <cstdint>
 class GrBackendSemaphore;
 
+namespace skgpu {
+enum class Protected : bool;
+enum class Renderable : bool;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
@@ -106,8 +110,6 @@ static const uint32_t kAll_GrBackendState = 0xffffffff;
 
 typedef void* GrGpuFinishedContext;
 typedef void (*GrGpuFinishedProc)(GrGpuFinishedContext finishedContext);
-typedef void (*GrGpuFinishedWithStatsProc)(GrGpuFinishedContext finishedContext,
-                                           const skgpu::GpuStats&);
 
 typedef void* GrGpuSubmittedContext;
 typedef void (*GrGpuSubmittedProc)(GrGpuSubmittedContext submittedContext, bool success);
@@ -129,15 +131,10 @@ typedef void (*GrDirectContextDestroyedProc)(GrDirectContextDestroyedContext des
  * and returned in initialized GrBackendSemaphore objects. The GrBackendSemaphore objects
  * themselves can be deleted as soon as this function returns.
  *
- * If a finishedProc or finishedWithStatsProc is provided, the proc will be called when all work
- * submitted to the gpu from this flush call and all previous flush calls has finished on the GPU.
- * If the flush call fails due to an error and nothing ends up getting sent to the GPU, the finished
- * proc is called immediately. If both types of proc are provided then finishedWithStatsProc is
- * preferred.
- *
- * When finishedWithStatsProc is called the GpuStats passed will contain valid values for stats
- * by requested by gpuStatsFlags, assuming the stats are supported by the underlying backend GPU
- * context and the GPU work completed successfully.
+ * If a finishedProc is provided, the finishedProc will be called when all work submitted to the gpu
+ * from this flush call and all previous flush calls has finished on the GPU. If the flush call
+ * fails due to an error and nothing ends up getting sent to the GPU, the finished proc is called
+ * immediately.
  *
  * If a submittedProc is provided, the submittedProc will be called when all work from this flush
  * call is submitted to the GPU. If the flush call fails due to an error and nothing will get sent
@@ -151,10 +148,8 @@ typedef void (*GrDirectContextDestroyedProc)(GrDirectContextDestroyedContext des
  */
 struct GrFlushInfo {
     size_t fNumSemaphores = 0;
-    skgpu::GpuStatsFlags fGpuStatsFlags = skgpu::GpuStatsFlags::kNone;
     GrBackendSemaphore* fSignalSemaphores = nullptr;
     GrGpuFinishedProc fFinishedProc = nullptr;
-    GrGpuFinishedWithStatsProc fFinishedWithStatsProc = nullptr;
     GrGpuFinishedContext fFinishedContext = nullptr;
     GrGpuSubmittedProc fSubmittedProc = nullptr;
     GrGpuSubmittedContext fSubmittedContext = nullptr;

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

@@ -16,10 +16,6 @@
 #include "include/gpu/graphite/Recorder.h"
 #include "include/private/base/SingleOwner.h"
 
-#if defined(GPU_TEST_UTILS)
-#include "include/private/base/SkMutex.h"
-#endif
-
 #include <chrono>
 #include <functional>
 #include <memory>
@@ -37,7 +33,7 @@ class Context;
 class ContextPriv;
 class GlobalCache;
 class PaintOptions;
-class PrecompileContext;
+class PlotUploadTracker;
 class QueueManager;
 class Recording;
 class ResourceProvider;
@@ -57,11 +53,6 @@ public:
 
     std::unique_ptr<Recorder> makeRecorder(const RecorderOptions& = {});
 
-    /** Creates a helper object that can be moved to a different thread and used
-     *  for precompilation.
-     */
-    std::unique_ptr<PrecompileContext> makePrecompileContext();
-
     bool insertRecording(const InsertRecordingInfo&);
     bool submit(SyncToCpu = SyncToCpu::kNo);
 
@@ -227,12 +218,6 @@ public:
      */
     size_t maxBudgetedBytes() const;
 
-    /**
-     * Sets the size of Context's gpu memory cache budget in bytes. If the new budget is lower than
-     * the current budget, the cache will try to free resources to get under the new budget.
-     */
-    void setMaxBudgetedBytes(size_t bytes);
-
     /**
      * Enumerates all cached GPU resources owned by the Context and dumps their memory to
      * traceMemoryDump.
@@ -255,11 +240,6 @@ public:
      */
     bool supportsProtectedContent() const;
 
-    /*
-     * Gets the types of GPU stats supported by this Context.
-     */
-    GpuStatsFlags supportedGpuStats() const;
-
     // Provides access to functions that aren't part of the public API.
     ContextPriv priv();
     const ContextPriv priv() const;  // NOLINT(readability-const-return-type)
@@ -363,14 +343,11 @@ private:
     mutable SingleOwner fSingleOwner;
 
 #if defined(GPU_TEST_UTILS)
-    void deregisterRecorder(const Recorder*) SK_EXCLUDES(fTestingLock);
-
     // 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
     // in any order we must also track the Recorders created here.
-    SkMutex fTestingLock;
-    std::vector<Recorder*> fTrackedRecorders SK_GUARDED_BY(fTestingLock);
+    std::vector<Recorder*> fTrackedRecorders;
 #endif
 
     // Needed for MessageBox handling

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

@@ -8,13 +8,11 @@
 #ifndef skgpu_graphite_ContextOptions_DEFINED
 #define skgpu_graphite_ContextOptions_DEFINED
 
-#include "include/core/SkRefCnt.h"
 #include "include/private/base/SkAPI.h"
 #include "include/private/base/SkMath.h"
 
 #include <optional>
 
-class SkData;
 namespace skgpu { class ShaderErrorHandler; }
 
 namespace skgpu::graphite {
@@ -87,12 +85,12 @@ struct SK_API ContextOptions {
     bool fSupportBilerpFromGlyphAtlas = false;
 
     /**
-     * For the moment, if Recordings are replayed in the order they are recorded, then
-     * Graphite can make certain assumptions that allow for better performance. Otherwise
-     * we have to flush some caches at the start of each Recording to ensure that they can
-     * be played back properly.
+     * 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 fRequireOrderedRecordings = false;
+    bool fDisableCachedGlyphUploads = false;
 
     static constexpr size_t kDefaultContextBudget = 256 * (1 << 20);
     /**
@@ -120,22 +118,6 @@ struct SK_API ContextOptions {
      */
     std::optional<uint64_t> fVulkanVMALargeHeapBlockSize;
 
-    /** Client-provided context that is passed to client-provided PipelineCallback. */
-    using PipelineCallbackContext = void*;
-    /**  Client-provided callback that is called whenever Graphite encounters a new Pipeline. */
-    using PipelineCallback = void (*)(PipelineCallbackContext context, sk_sp<SkData> pipelineData);
-
-    /**
-     *  These two members allow a client to register a callback that will be invoked
-     *  whenever Graphite encounters a new Pipeline. The callback will be passed an
-     *  sk_sp<SkData> that a client can take ownership of and serialize. The SkData
-     *  contains all the information Graphite requires to recreate the Pipeline at
-     *  a later date. The SkData is versioned however, so must be regenerated and
-     *  re-serialized when it becomes out of date.
-     */
-    PipelineCallbackContext fPipelineCallbackContext = nullptr;
-    PipelineCallback fPipelineCallback = nullptr;
-
     /**
      * Private options that are only meant for testing within Skia's tools.
      */

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

@@ -30,23 +30,13 @@ class Task;
 using GpuFinishedContext = void*;
 using GpuFinishedProc = void (*)(GpuFinishedContext finishedContext, CallbackResult);
 
-using GpuFinishedWithStatsProc = void (*)(GpuFinishedContext finishedContext,
-                                          CallbackResult,
-                                          const GpuStats&);
-
 /**
  * The fFinishedProc is called when the Recording has been submitted and finished on the GPU, or
  * when there is a failure that caused it not to be submitted. The callback will always be called
  * and the caller can use the callback to know it is safe to free any resources associated with
  * the Recording that they may be holding onto. If the Recording is successfully submitted to the
  * GPU the callback will be called with CallbackResult::kSuccess once the GPU has finished. All
- * other cases where some failure occurred it will be called with CallbackResult::kFailed.
- *
- * Alternatively, the client can provide fFinishedProcWithStats. This provides additional
- * information about execution of the recording on the GPU. Only the stats requested using
- * fStatsFlags will be valid and only if CallbackResult is kSuccess. If both fFinishedProc
- * and fFinishedProcWithStats are provided the latter is preferred and the former won't be
- * called.
+ * other cases where some failure occured it will be called with CallbackResult::kFailed.
  *
  * The fTargetSurface, if provided, is used as a target for any draws recorded onto a deferred
  * canvas returned from Recorder::makeDeferredCanvas. This target surface must be provided iff
@@ -84,10 +74,8 @@ struct InsertRecordingInfo {
     size_t fNumSignalSemaphores = 0;
     BackendSemaphore* fSignalSemaphores = nullptr;
 
-    GpuStatsFlags fGpuStatsFlags = GpuStatsFlags::kNone;
     GpuFinishedContext fFinishedContext = nullptr;
     GpuFinishedProc fFinishedProc = nullptr;
-    GpuFinishedWithStatsProc fFinishedWithStatsProc = nullptr;
 };
 
 /**
@@ -99,15 +87,8 @@ struct InsertRecordingInfo {
  * other cases where some failure occured it will be called with CallbackResult::kFailed.
  */
 struct InsertFinishInfo {
-    InsertFinishInfo() = default;
-    InsertFinishInfo(GpuFinishedContext context, GpuFinishedProc proc)
-            : fFinishedContext{context}, fFinishedProc{proc} {}
-    InsertFinishInfo(GpuFinishedContext context, GpuFinishedWithStatsProc proc)
-            : fFinishedContext{context}, fFinishedWithStatsProc{proc} {}
     GpuFinishedContext fFinishedContext = nullptr;
     GpuFinishedProc fFinishedProc = nullptr;
-    GpuFinishedWithStatsProc fFinishedWithStatsProc = nullptr;
-    GpuStatsFlags fGpuStatsFlags = GpuStatsFlags::kNone;
 };
 
 /**

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

@@ -15,7 +15,6 @@
 #include "include/gpu/GpuTypes.h"
 
 #include <string_view>
-#include <tuple>
 
 class SkYUVAInfo;
 class SkYUVAPixmaps;

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

@@ -209,12 +209,6 @@ public:
      */
     size_t maxBudgetedBytes() const;
 
-    /**
-     * Sets the size of Recorders's gpu memory cache budget in bytes. If the new budget is lower
-     * than the current budget, the cache will try to free resources to get under the new budget.
-     */
-    void setMaxBudgetedBytes(size_t bytes);
-
     /**
      * Enumerates all cached GPU resources owned by the Recorder and dumps their memory to
      * traceMemoryDump.

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

@@ -9,7 +9,6 @@
 #define skgpu_graphite_Recording_DEFINED
 
 #include "include/core/SkRefCnt.h"
-#include "include/core/SkSize.h"
 #include "include/private/base/SkTArray.h"
 
 #include <memory>
@@ -22,7 +21,6 @@ class RefCntedCallback;
 
 namespace skgpu::graphite {
 
-class Caps;
 class CommandBuffer;
 class RecordingPriv;
 class Resource;
@@ -46,7 +44,7 @@ private:
     // replay, and it handles the target proxy's instantiation with the provided target.
     class LazyProxyData {
     public:
-        LazyProxyData(const Caps*, SkISize dimensions, const TextureInfo&);
+        LazyProxyData(const TextureInfo&);
 
         TextureProxy* lazyProxy();
         sk_sp<TextureProxy> refLazyProxy();