@shopify/react-native-skia 1.12.0 → 1.12.2

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

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

@@ -8,11 +8,13 @@
 #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 {
@@ -85,12 +87,12 @@ struct SK_API ContextOptions {
     bool fSupportBilerpFromGlyphAtlas = false;
 
     /**
-     * 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.
+     * 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.
      */
-    bool fDisableCachedGlyphUploads = false;
+    bool fRequireOrderedRecordings = false;
 
     static constexpr size_t kDefaultContextBudget = 256 * (1 << 20);
     /**
@@ -118,6 +120,22 @@ 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,13 +30,23 @@ 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 occured it will be called with CallbackResult::kFailed.
+ * 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.
  *
  * 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
@@ -74,8 +84,10 @@ struct InsertRecordingInfo {
     size_t fNumSignalSemaphores = 0;
     BackendSemaphore* fSignalSemaphores = nullptr;
 
+    GpuStatsFlags fGpuStatsFlags = GpuStatsFlags::kNone;
     GpuFinishedContext fFinishedContext = nullptr;
     GpuFinishedProc fFinishedProc = nullptr;
+    GpuFinishedWithStatsProc fFinishedWithStatsProc = nullptr;
 };
 
 /**
@@ -87,8 +99,15 @@ 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;
 };
 
 /**