@shopify/react-native-skia 2.0.0-next.1 → 2.0.0-next.3

package/cpp/skia/include/core/SkSurface.h

@@ -330,6 +330,20 @@ public:
      */
     sk_sp<SkImage> makeImageSnapshot(const SkIRect& bounds);
 
+    /** Returns an SkImage capturing the current SkSurface contents. However, the contents of the
+        SkImage are only valid as long as no other writes to the SkSurface occur. If writes to the
+        original SkSurface happen then contents of the SkImage are undefined. However, continued use
+        of the SkImage should not cause crashes or similar fatal behavior.
+
+        This API is useful for cases where the client either immediately destroys the SkSurface
+        after the SkImage is created or knows they will destroy the SkImage before writing to the
+        SkSurface again.
+
+        This API can be more performant than makeImageSnapshot as it never does an internal copy
+        of the data assuming the user frees either the SkImage or SkSurface as described above.
+     */
+    sk_sp<SkImage> makeTemporaryImage();
+
     /** Draws SkSurface contents to canvas, with its top-left corner at (x, y).
 
         If SkPaint paint is not nullptr, apply SkColorFilter, alpha, SkImageFilter, and SkBlendMode.

package/cpp/skia/include/core/SkTypeface.h

@@ -53,20 +53,18 @@ typedef uint32_t SkFontTableTag;
 class SK_API SkTypeface : public SkWeakRefCnt {
 public:
     /** Returns the typeface's intrinsic style attributes. */
-    SkFontStyle fontStyle() const {
-        return fStyle;
-    }
+    SkFontStyle fontStyle() const;
 
     /** Returns true if style() has the kBold bit set. */
-    bool isBold() const { return fStyle.weight() >= SkFontStyle::kSemiBold_Weight; }
+    bool isBold() const;
 
     /** Returns true if style() has the kItalic bit set. */
-    bool isItalic() const { return fStyle.slant() != SkFontStyle::kUpright_Slant; }
+    bool isItalic() const;
 
     /** Returns true if the typeface claims to be fixed-pitch.
      *  This is a style bit, advance widths may vary even if this returns true.
      */
-    bool isFixedPitch() const { return fIsFixedPitch; }
+    bool isFixedPitch() const;
 
     /** Copy into 'coordinates' (allocated by the caller) the design variation coordinates.
      *
@@ -287,6 +285,20 @@ public:
      */
     bool getPostScriptName(SkString* name) const;
 
+    /**
+     *  If the primary resource backing this typeface has a name (like a file
+     *  path or URL) representable by unicode code points, the `resourceName`
+     *  will be set. The primary purpose is as a user facing indication about
+     *  where the data was obtained (which font file was used).
+     *
+     *  Returns the number of resources backing this typeface.
+     *
+     *  For local font collections resource name will often be a file path. The
+     *  file path may or may not exist. If it does exist, using it to create an
+     *  SkTypeface may or may not create a similar SkTypeface to this one.
+     */
+    int getResourceName(SkString* resourceName) const;
+
     /**
      *  Return a stream for the contents of the font data, or NULL on failure.
      *  If ttcIndex is not null, it is set to the TrueTypeCollection index
@@ -349,6 +361,10 @@ protected:
     /** Sets the font style. If used, must be called in the constructor. */
     void setFontStyle(SkFontStyle style) { fStyle = style; }
 
+    virtual SkFontStyle onGetFontStyle() const; // TODO: = 0;
+
+    virtual bool onGetFixedPitch() const; // TODO: = 0;
+
     // Must return a valid scaler context. It can not return nullptr.
     virtual std::unique_ptr<SkScalerContext> onCreateScalerContext(const SkScalerContextEffects&,
                                                                    const SkDescriptor*) const = 0;
@@ -398,6 +414,7 @@ protected:
      */
     virtual void onGetFamilyName(SkString* familyName) const = 0;
     virtual bool onGetPostScriptName(SkString*) const = 0;
+    virtual int onGetResourceName(SkString* resourceName) const; // TODO: = 0;
 
     /** Returns an iterator over the family names in the font. */
     virtual LocalizedStrings* onCreateFamilyNameIterator() const = 0;
@@ -424,7 +441,7 @@ private:
     std::unique_ptr<SkAdvancedTypefaceMetrics> getAdvancedMetrics() const;
     friend class SkRandomTypeface;   // getAdvancedMetrics
     friend class SkPDFFont;          // getAdvancedMetrics
-    friend class SkTypeface_fontconfig;
+    friend class SkTypeface_proxy;
 
     friend class SkFontPriv;         // getGlyphToUnicodeMap
 

package/cpp/skia/include/effects/SkGradientShader.h

@@ -94,7 +94,12 @@ public:
             kHSL,
             kHWB,
 
-            kLastColorSpace = kHWB,
+            kDisplayP3,
+            kRec2020,
+            kProphotoRGB,
+            kA98RGB,
+
+            kLastColorSpace = kA98RGB,
         };
         static constexpr int kColorSpaceCount = static_cast<int>(ColorSpace::kLastColorSpace) + 1;
 

package/cpp/skia/include/effects/SkRuntimeEffect.h

@@ -170,6 +170,7 @@ public:
 
     // Shader SkSL requires an entry point that looks like:
     //     vec4 main(vec2 inCoords) { ... }
+    // The color that is returned should be premultiplied.
     static Result MakeForShader(SkString sksl, const Options&);
     static Result MakeForShader(SkString sksl) {
         return MakeForShader(std::move(sksl), Options{});

package/cpp/skia/include/encode/SkPngEncoder.h

@@ -23,6 +23,7 @@ class SkImage;
 class SkPixmap;
 class SkWStream;
 struct skcms_ICCProfile;
+struct SkGainmapInfo;
 
 namespace SkPngEncoder {
 
@@ -80,6 +81,19 @@ struct Options {
      */
     const skcms_ICCProfile* fICCProfile = nullptr;
     const char* fICCProfileDescription = nullptr;
+
+    /**
+     * If non-null, then a gainmap and its metadata will be encoded as png chunks.
+     * The gainmap will be encoded in a gmAP chunk as a full PNG container. The
+     * gainmap info will be encoded in a gdAT chunk inside of the gmAP chunk.
+     * This effectively is Option B proposed in this discussion for adding gainmaps
+     * into PNG: https://github.com/w3c/png/issues/380#issuecomment-2325163149.
+     *
+     * Note that if fGainmapInfo is null, then fGainmap will fail to encode, as the
+     * gainmap metadata is required to correctly interpret the encoded gainmap.
+     */
+    const SkPixmap* fGainmap = nullptr;
+    const SkGainmapInfo* fGainmapInfo = nullptr;
 };
 
 /**

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

@@ -79,6 +79,15 @@ enum class Origin : unsigned {
     kBottomLeft,
 };
 
+enum class GpuStatsFlags : uint32_t {
+    kNone = 0b00,
+    kElapsedTime = 0b01,
+};
+
+struct GpuStats {
+    uint64_t elapsedTime = 0;
+};
+
 } // namespace skgpu
 
 

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

@@ -75,8 +75,55 @@ struct SK_API GrContextOptions {
 
     GrContextOptions() {}
 
-    // Suppress prints for the GrContext.
-    bool fSuppressPrints = false;
+    /**
+     * 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;
 
     /**
      * Controls whether we check for GL errors after functions that allocate resources (e.g.
@@ -86,6 +133,33 @@ 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. */
@@ -97,19 +171,48 @@ struct SK_API GrContextOptions {
         deduce the optimal value for this platform. */
     int  fBufferMapThreshold = -1;
 
-    /** 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;
+    /**
+     * Maximum number of GPU programs or pipelines to keep active in the runtime cache.
+     */
+    int fRuntimeProgramCacheSize = 256;
 
     /**
-     * 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.
+     * 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.
      */
-    SkExecutor* fExecutor = nullptr;
+    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;
+
+    /**
+     * 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
+
+    GrDriverBugWorkarounds fDriverBugWorkarounds;
 
     /** Construct mipmaps manually, via repeated downsampling draw-calls. This is used when
         the driver's implementation (glGenerateMipmap) contains bugs. This requires mipmap
@@ -142,34 +245,6 @@ 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.
@@ -183,19 +258,6 @@ 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
@@ -210,60 +272,6 @@ 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.
      */
@@ -307,20 +315,32 @@ struct SK_API GrContextOptions {
      */
     bool fAlwaysUseTexStorageWhenAvailable = false;
 
-    /**
-     * 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;
+    // 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.
+     */
+    int fResourceCacheLimitOverride = -1;
+
+    /**
+     * Maximum width and height of internal texture atlases.
+     */
+    int  fMaxTextureAtlasSize = 2048;
+
     /**
      * Testing-only mode to exercise allocation failures in the flush-time callback objects.
      * For now it only simulates allocation failure during the preFlush callback.
@@ -368,26 +388,8 @@ 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,6 +271,11 @@ 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,8 +34,10 @@ enum GrDriverBugWorkaroundType {
 
 class SK_API GrDriverBugWorkarounds {
  public:
-  GrDriverBugWorkarounds();
+  GrDriverBugWorkarounds() = default;
   GrDriverBugWorkarounds(const GrDriverBugWorkarounds&) = default;
+  ~GrDriverBugWorkarounds() = default;
+
   explicit GrDriverBugWorkarounds(const std::vector<int32_t>& workarounds);
 
   GrDriverBugWorkarounds& operator=(const GrDriverBugWorkarounds&) = default;
@@ -43,8 +45,6 @@ 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,17 +9,13 @@
 #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;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
@@ -110,6 +106,8 @@ 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);
@@ -131,10 +129,15 @@ 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 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 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 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
@@ -148,8 +151,10 @@ 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,6 +16,10 @@
 #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>
@@ -33,7 +37,7 @@ class Context;
 class ContextPriv;
 class GlobalCache;
 class PaintOptions;
-class PlotUploadTracker;
+class PrecompileContext;
 class QueueManager;
 class Recording;
 class ResourceProvider;
@@ -53,6 +57,11 @@ 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);
 
@@ -218,6 +227,12 @@ 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.
@@ -240,6 +255,11 @@ 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)
@@ -343,11 +363,14 @@ 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.
-    std::vector<Recorder*> fTrackedRecorders;
+    SkMutex fTestingLock;
+    std::vector<Recorder*> fTrackedRecorders SK_GUARDED_BY(fTestingLock);
 #endif
 
     // Needed for MessageBox handling