@shopify/react-native-skia 2.2.21 → 2.3.4

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

@@ -9,13 +9,13 @@
 #define SkShader_DEFINED
 
 #include "include/core/SkColor.h"
+#include "include/core/SkColorSpace.h"
 #include "include/core/SkFlattenable.h"
 #include "include/core/SkRefCnt.h"
 #include "include/private/base/SkAPI.h"
 
 class SkBlender;
 class SkColorFilter;
-class SkColorSpace;
 class SkImage;
 class SkMatrix;
 enum class SkBlendMode;
@@ -69,13 +69,26 @@ public:
     sk_sp<SkShader> makeWithColorFilter(sk_sp<SkColorFilter>) const;
 
     /**
-     *  Return a shader that will compute this shader in a specific color space.
-     *  By default, all shaders operate in the destination (surface) color space.
-     *  The results of a shader are still always converted to the destination - this
-     *  API has no impact on simple shaders or images. Primarily, it impacts shaders
-     *  that perform mathematical operations, like Blend shaders, or runtime shaders.
+     *  Return a shader that will compute this shader in a context such that any child shaders
+     *  return RGBA values converted to the `inputCS` colorspace.
+     *
+     *  It is then assumed that the RGBA values returned by this shader have been transformed into
+     *  `outputCS` by the shader being wrapped.  By default, shaders are assumed to return values
+     *  in the destination colorspace and premultiplied. Using a different outputCS than inputCS
+     *  allows custom shaders to replace the color management Skia normally performs w/o forcing
+     *  authors to otherwise manipulate surface/image color info to avoid unnecessary or incorrect
+     *  work.
+     *
+     *  If the shader is not performing colorspace conversion but needs to operate in the `inputCS`
+     *  then it should have `outputCS` be the same as `inputCS`. Regardless of the `outputCS` here,
+     *  the RGBA values of the returned SkShader are always converted from `outputCS` to the
+     *  destination surface color space.
+     *
+     *  A null inputCS is assumed to be the destination CS.
+     *  A null outputCS is assumed to be the inputCS.
      */
-    sk_sp<SkShader> makeWithWorkingColorSpace(sk_sp<SkColorSpace>) const;
+    sk_sp<SkShader> makeWithWorkingColorSpace(sk_sp<SkColorSpace> inputCS,
+                                              sk_sp<SkColorSpace> outputCS=nullptr) const;
 
 private:
     SkShader() = default;

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

@@ -17,6 +17,7 @@
 #include <cstdint>
 
 class SkPath;
+class SkPathBuilder;
 
 SK_BEGIN_REQUIRE_DENSE
 class SK_API SkStrokeRec {
@@ -96,7 +97,7 @@ public:
      *
      *  src and dst may be the same path.
      */
-    bool applyToPath(SkPath* dst, const SkPath& src) const;
+    bool applyToPath(SkPathBuilder* dst, const SkPath& src) const;
 
     /**
      *  Apply these stroke parameters to a paint.

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

@@ -410,7 +410,7 @@ protected:
     // The mapping from glyph to Unicode; array indices are glyph ids.
     // For each glyph, give the default Unicode value, if it exists.
     // dstArray is non-null, and points to an array of size this->countGlyphs().
-    virtual void getGlyphToUnicodeMap(SkUnichar* dstArray) const = 0;
+    virtual void getGlyphToUnicodeMap(SkSpan<SkUnichar> dstArray) const = 0;
 
     virtual std::unique_ptr<SkStreamAsset> onOpenStream(int* ttcIndex) const = 0;
 
@@ -419,20 +419,18 @@ protected:
     virtual bool onGlyphMaskNeedsCurrentColor() const = 0;
 
     virtual int onGetVariationDesignPosition(
-        SkFontArguments::VariationPosition::Coordinate coordinates[],
-        int coordinateCount) const = 0;
+                                 SkSpan<SkFontArguments::VariationPosition::Coordinate>) const = 0;
 
-    virtual int onGetVariationDesignParameters(
-        SkFontParameters::Variation::Axis parameters[], int parameterCount) const = 0;
+    virtual int onGetVariationDesignParameters(SkSpan<SkFontParameters::Variation::Axis>) const = 0;
 
     virtual void onGetFontDescriptor(SkFontDescriptor*, bool* isLocal) const = 0;
 
-    virtual void onCharsToGlyphs(const SkUnichar* chars, int count, SkGlyphID glyphs[]) const = 0;
+    virtual void onCharsToGlyphs(SkSpan<const SkUnichar>, SkSpan<SkGlyphID>) const = 0;
     virtual int onCountGlyphs() const = 0;
 
     virtual int onGetUPEM() const = 0;
-    virtual bool onGetKerningPairAdjustments(const SkGlyphID glyphs[], int count,
-                                             int32_t adjustments[]) const;
+    virtual bool onGetKerningPairAdjustments(SkSpan<const SkGlyphID>,
+                                             SkSpan<int32_t> adjustments) const;
 
     /** Returns the family name of the typeface as known by its font manager.
      *  This name may or may not be produced by the family name iterator.
@@ -444,7 +442,7 @@ protected:
     /** Returns an iterator over the family names in the font. */
     virtual LocalizedStrings* onCreateFamilyNameIterator() const = 0;
 
-    virtual int onGetTableTags(SkFontTableTag tags[]) const = 0;
+    virtual int onGetTableTags(SkSpan<SkFontTableTag>) const = 0;
     virtual size_t onGetTableData(SkFontTableTag, size_t offset,
                                   size_t length, void* data) const = 0;
     virtual sk_sp<SkData> onCopyTableData(SkFontTableTag) const;
@@ -468,7 +466,7 @@ private:
     friend class SkPDFFont;          // getAdvancedMetrics
     friend class SkTypeface_proxy;
     friend class SkFontPriv;         // getGlyphToUnicodeMap
-    friend void TestSkTypefaceGlyphToUnicodeMap(SkTypeface&, SkUnichar*);
+    friend void TestSkTypefaceGlyphToUnicodeMap(SkTypeface&, SkSpan<SkUnichar>);
 
 private:
     SkTypefaceID        fUniqueID;

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

@@ -149,6 +149,10 @@
 #   define SK_ENABLE_LEGACY_SHADERCONTEXT
 #endif
 
+#ifndef SK_SUPPORT_MUTABLE_PATHEFFECT
+#   define SK_SUPPORT_MUTABLE_PATHEFFECT
+#endif
+
 #if defined(SK_BUILD_FOR_LIBFUZZER) || defined(SK_BUILD_FOR_AFL_FUZZ)
 #if !defined(SK_BUILD_FOR_FUZZER)
     #define SK_BUILD_FOR_FUZZER

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

@@ -79,16 +79,6 @@ struct Options {
      */
     const SkData* xmpMetadata = nullptr;
 
-    /**
-     *  An optional ICC profile to override the default behavior.
-     *
-     *  The default behavior is to generate an ICC profile using a primary matrix and
-     *  analytic transfer function. If the color space of |src| cannot be represented
-     *  in this way (e.g, it is HLG or PQ), then no profile will be embedded.
-     */
-    const skcms_ICCProfile* fICCProfile = nullptr;
-    const char* fICCProfileDescription = nullptr;
-
     std::optional<SkEncodedOrigin> fOrigin;
 };
 
@@ -104,6 +94,11 @@ SK_API bool Encode(SkWStream* dst,
                    const SkColorSpace* srcColorSpace,
                    const Options& options);
 
+/**
+ *  Returns the encoded data for the pixmap, or nullptr on failure.
+ */
+SK_API sk_sp<SkData> Encode(const SkPixmap& src, const Options& options);
+
 /**
 *  Encode the provided image and return the resulting bytes. If the image was created as
 *  a texture-backed image on a GPU context, that |ctx| must be provided so the pixels

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

@@ -10,6 +10,7 @@
 
 #include "include/core/SkDataTable.h"
 #include "include/core/SkRefCnt.h"
+#include "include/private/SkHdrMetadata.h"
 #include "include/private/base/SkAPI.h"
 
 // TODO(kjlubick) update clients to directly include this
@@ -73,14 +74,9 @@ struct Options {
     sk_sp<SkDataTable> fComments;
 
     /**
-     * An optional ICC profile to override the default behavior.
-     *
-     * The default behavior is to generate an ICC profile using a primary matrix and
-     * analytic transfer function. If the color space of |src| cannot be represented
-     * in this way (e.g, it is HLG or PQ), then no profile will be embedded.
+     * Container for any HDR metadata to include in the encoded image.
      */
-    const skcms_ICCProfile* fICCProfile = nullptr;
-    const char* fICCProfileDescription = nullptr;
+    skhdr::Metadata fHdrMetadata;
 
     /**
      * If non-null, then a gainmap and its metadata will be encoded as png chunks.
@@ -104,6 +100,11 @@ struct Options {
  */
 SK_API bool Encode(SkWStream* dst, const SkPixmap& src, const Options& options);
 
+/**
+ *  Returns the encoded data for the pixmap, or nullptr on failure.
+ */
+SK_API sk_sp<SkData> Encode(const SkPixmap& src, const Options& options);
+
 /**
 *  Encode the provided image and return the resulting bytes. If the image was created as
 *  a texture-backed image on a GPU context, that |ctx| must be provided so the pixels

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

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2024 Google LLC.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkPngRustEncoder_DEFINED
+#define SkPngRustEncoder_DEFINED
+
+#include <cstdint>
+#include <memory>
+
+#include "include/core/SkDataTable.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+class SkEncoder;
+class SkPixmap;
+class SkWStream;
+
+namespace SkPngRustEncoder {
+
+/*
+ * Compression level.
+ */
+enum class CompressionLevel : uint8_t {
+    // Low compression level - fast, but may result in bigger PNG files.
+    kLow,
+
+    // Medium compression level - somewhere in-between `kLow` and `kHigh`.
+    kMedium,
+
+    // High compression level - slow, but should results in smaller PNG files.
+    kHigh,
+};
+
+/*
+ * PNG encoding options.
+ *
+ * TODO(https://crbug.com/379312510): Add support for `SkPngEncoder::Options`
+ * like:
+ *  - Comments - `tEXt` chunks.
+ *  - Color profile - `iCCP` chunk.
+ */
+struct Options {
+    CompressionLevel fCompressionLevel = CompressionLevel::kMedium;
+
+    /**
+     *  Represents comments to be written into tEXt chunks of the png.
+     *
+     *  The 2i-th entry is the keyword for the i-th comment,
+     *  and the (2i + 1)-th entry is the text for the i-th comment.
+     *
+     *  All entries are treated as strings encoded as Latin-1 (i.e.
+     *  ISO-8859-1).  The strings may, but don't have to be NUL-terminated
+     *  (trailing NUL characters will be stripped).  Encoding will fail if
+     *  keyword or text don't meet the requirements of the PNG spec - text may
+     *  have any length and contain any of the 191 Latin-1 characters (and/or
+     *  the linefeed character), but keyword's length is restricted to at most
+     *  79 characters and it can't contain a non-breaking space character.
+     */
+    sk_sp<SkDataTable> fComments;
+};
+
+/**
+ *  Encode the |src| pixels to the |dst| stream.
+ *  |options| may be used to control the encoding behavior.
+ *
+ *  Returns true on success.  Returns false on an invalid or unsupported |src|.
+ *
+ */
+SK_API bool Encode(SkWStream* dst, const SkPixmap& src, const Options& options);
+
+/**
+ *  Create a png encoder that will encode the |src| pixels to the |dst| stream.
+ *  |options| may be used to control the encoding behavior.
+ *
+ *  The primary use of this is incremental encoding of the pixels.
+ *
+ *  |dst| is unowned but must remain valid for the lifetime of the object.
+ *
+ *  This returns nullptr on an invalid or unsupported |src|.
+ */
+SK_API std::unique_ptr<SkEncoder> Make(SkWStream* dst, const SkPixmap& src, const Options& options);
+
+}  // namespace SkPngRustEncoder
+
+#endif  // SkPngRustEncoder_DEFINED

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

@@ -42,16 +42,6 @@ struct SK_API Options {
      */
     Compression fCompression = Compression::kLossy;
     float fQuality = 100.0f;
-
-    /**
-     * An optional ICC profile to override the default behavior.
-     *
-     * The default behavior is to generate an ICC profile using a primary matrix and
-     * analytic transfer function. If the color space of |src| cannot be represented
-     * in this way (e.g, it is HLG or PQ), then no profile will be embedded.
-     */
-    const skcms_ICCProfile* fICCProfile = nullptr;
-    const char* fICCProfileDescription = nullptr;
 };
 
 /**
@@ -62,6 +52,11 @@ struct SK_API Options {
  */
 SK_API bool Encode(SkWStream* dst, const SkPixmap& src, const Options& options);
 
+/**
+ *  Returns the encoded data for the pixmap, or nullptr on failure.
+ */
+SK_API sk_sp<SkData> Encode(const SkPixmap& src, const Options& options);
+
 /**
 *  Encode the provided image and return the resulting bytes. If the image was created as
 *  a texture-backed image on a GPU context, that |ctx| must be provided so the pixels

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

@@ -8,10 +8,13 @@
 #ifndef skgpu_graphite_BackendSemaphore_DEFINED
 #define skgpu_graphite_BackendSemaphore_DEFINED
 
-#include "include/core/SkRefCnt.h"
-#include "include/gpu/graphite/GraphiteTypes.h"
+#include "include/private/base/SkAPI.h"
 #include "include/private/base/SkAnySubclass.h"
 
+#include <cstddef>
+
+namespace skgpu { enum class BackendApi : unsigned int; }
+
 namespace skgpu::graphite {
 
 class BackendSemaphoreData;

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

@@ -8,12 +8,15 @@
 #ifndef skgpu_graphite_BackendTexture_DEFINED
 #define skgpu_graphite_BackendTexture_DEFINED
 
-#include "include/core/SkRefCnt.h"
 #include "include/core/SkSize.h"
-#include "include/gpu/graphite/GraphiteTypes.h"
 #include "include/gpu/graphite/TextureInfo.h"
+#include "include/private/base/SkAPI.h"
 #include "include/private/base/SkAnySubclass.h"
 
+#include <cstddef>
+
+namespace skgpu { enum class BackendApi : unsigned int; }
+
 namespace skgpu::graphite {
 
 class BackendTextureData;

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

@@ -79,8 +79,8 @@ public:
      */
     std::unique_ptr<PrecompileContext> makePrecompileContext();
 
-    bool insertRecording(const InsertRecordingInfo&);
-    bool submit(SyncToCpu = SyncToCpu::kNo);
+    InsertStatus insertRecording(const InsertRecordingInfo&);
+    bool submit(SubmitInfo submitInfo = {});
 
     /** Returns true if there is work that was submitted to the GPU that has not finished. */
     bool hasUnfinishedGpuWork() const;
@@ -277,6 +277,19 @@ public:
      */
     GpuStatsFlags supportedGpuStats() const;
 
+    /*
+     * TODO (b/412351769): Do not use startCapture() or endCapture() as the feature is still under
+     * development.
+     *
+     * Starts the SkCapture. Must have set ContextOptions::fEnableCapture to start.
+     */
+    void startCapture();
+
+    /*
+     * Ends the SkCapture and returns the collected draws and surface creation.
+     */
+    void endCapture();
+
     // Provides access to functions that aren't part of the public API.
     ContextPriv priv();
     const ContextPriv priv() const;  // NOLINT(readability-const-return-type)

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

@@ -17,6 +17,7 @@
 #include <optional>
 
 class SkData;
+class SkExecutor;
 class SkRuntimeEffect;
 namespace skgpu { class ShaderErrorHandler; }
 
@@ -57,6 +58,14 @@ struct SK_API ContextOptions {
      */
     std::optional<SkISize> fInternalMSAATileSize = std::nullopt;
 
+    /**
+     * If set, paths that are smaller than this size (in device space) will avoid MSAA techniques,
+     * even if MSAA is otherwise enabled via `fInternalMultisampleCount`. This should be smaller
+     * than `fGlyphsAsPathsFontSize` or large glyphs will not correctly avoid higher memory
+     * overhead.
+     */
+    float fMinimumPathSizeForMSAA = 0;
+
     /**
      * Will the client make sure to only ever be executing one thread that uses the Context and all
      * derived classes (e.g. Recorders, Recordings, etc.) at a time. If so we can possibly make some
@@ -171,6 +180,23 @@ struct SK_API ContextOptions {
      */
     SkSpan<sk_sp<SkRuntimeEffect>> fUserDefinedKnownRuntimeEffects;
 
+    /**
+     * Executor to handle threaded work within Graphite. 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 Pipeline compilation, but may be used
+     * for other tasks. It is up to the client to ensure the SkExecutor remains valid throughout
+     * the lifetime of the Context.
+     */
+    SkExecutor* fExecutor = nullptr;
+
+    /**
+     * An experimental flag in development. Behavior and performance is subject to change.
+     *
+     * Enables the use of startCapture and endCapture functions. Calling these APIs will capture all
+     * draw calls and surface creation from Recorders spawned from the Context.
+     */
+     bool fEnableCapture = false;
+
     /**
      * Private options that are only meant for testing within Skia's tools.
      */

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

@@ -34,6 +34,47 @@ using GpuFinishedWithStatsProc = void (*)(GpuFinishedContext finishedContext,
                                           CallbackResult,
                                           const GpuStats&);
 
+// NOTE: This can be converted to just an `enum class InsertStatus {}` once clients are migrated
+// off of assuming `Context::insertRecording()` returns a boolean.
+class InsertStatus {
+public:
+    // Do not refer to V directly; use these constants as if InsertStatus were a class enum, e.g.
+    // InsertStatus::kSuccess.
+    enum V {
+        // Everything successfully added to underlying CommandBuffer
+        kSuccess,
+        // Recording or InsertRecordingInfo invalid, no CB changes
+        kInvalidRecording,
+        // Promise image instantiation failed, no CB changes
+        kPromiseImageInstantiationFailed,
+        // Internal failure, CB partially modified, state unrecoverable or unknown (e.g. dependent
+        // texture uploads for future Recordings may or may not get executed)
+        kAddCommandsFailed,
+        // Internal failure, shader pipeline compilation failed (driver issue, or disk corruption),
+        // state unrecoverable.
+        kAsyncShaderCompilesFailed
+    };
+
+    constexpr InsertStatus() : fValue(kSuccess) {}
+    /*implicit*/ constexpr InsertStatus(V v) : fValue(v) {}
+
+    operator InsertStatus::V() const {
+        return fValue;
+    }
+
+    // Assist migration from old bool return value of insertRecording; kSuccess is true,
+    // all other error statuses are false.
+    // NOTE: This is intentionally not explicit so that InsertStatus can be assigned correctly to
+    // a bool or returned as a bool, since these are not boolean contexts that automatically apply
+    // explicit bool operators (e.g. inside an if condition).
+    operator bool() const {
+        return fValue == kSuccess;
+    }
+
+private:
+    V fValue;
+};
+
 /**
  * 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
@@ -88,6 +129,17 @@ struct InsertRecordingInfo {
     GpuFinishedContext fFinishedContext = nullptr;
     GpuFinishedProc fFinishedProc = nullptr;
     GpuFinishedWithStatsProc fFinishedWithStatsProc = nullptr;
+
+    // For unit testing purposes, this can be used to induce a known failure status from
+    // Context::insertRecording(). When this set to anything other than kSuccess, insertRecording()
+    // will operate as normal until the first condition that would normally return the simulated
+    // status is encountered. At that point, operations are treated as if that condition had failed.
+    // This leaves the Context in a state consistent with encountering the InsertStatus in a normal
+    // application.
+    //
+    // NOTE: If the simulated failure status is one of the later error codes but the inserted
+    // Recording would fail with an earlier error code normally, that error is still returned.
+    InsertStatus fSimulatedStatus = InsertStatus::kSuccess;
 };
 
 /**
@@ -118,6 +170,29 @@ enum class SyncToCpu : bool {
     kNo = false
 };
 
+enum class MarkFrameBoundary : bool {
+    kYes = true,
+    kNo = false
+};
+
+struct SubmitInfo {
+    SyncToCpu fSync = SyncToCpu::kNo;
+    MarkFrameBoundary fMarkBoundary = MarkFrameBoundary::kNo;
+    uint64_t fFrameID = 0;
+
+    constexpr SubmitInfo() = default;
+
+    constexpr SubmitInfo(SyncToCpu sync)
+        : fSync(sync)
+        , fMarkBoundary(MarkFrameBoundary::kNo)
+        , fFrameID(0) {}
+
+    constexpr SubmitInfo(SyncToCpu sync, uint64_t frameID)
+        : fSync(sync)
+        , fMarkBoundary(MarkFrameBoundary::kYes)
+        , fFrameID(frameID) {}
+};
+
 /*
  * For Promise Images - should the Promise Image be fulfilled every time a Recording that references
  * it is inserted into the Context.

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

@@ -16,6 +16,7 @@
 #include "include/private/base/SingleOwner.h"
 #include "include/private/base/SkAPI.h"
 #include "include/private/base/SkTArray.h"
+#include "include/private/base/SkTDArray.h"
 
 #include <chrono>
 #include <cstddef>
@@ -51,6 +52,7 @@ class BackendTexture;
 class Context;
 class Device;
 class DrawBufferManager;
+class FloatStorageManager;
 class ImageProvider;
 class ProxyReadCountMap;
 class RecorderPriv;
@@ -58,16 +60,12 @@ class ResourceProvider;
 class RuntimeEffectDictionary;
 class SharedContext;
 class TaskList;
-class TextureDataBlock;
 class TextureInfo;
 class UploadBufferManager;
 class UploadList;
 
 struct RecorderOptionsPriv;
 
-template<typename T> class PipelineDataCache;
-using TextureDataCache = PipelineDataCache<TextureDataBlock>;
-
 struct SK_API RecorderOptions final {
     RecorderOptions();
     RecorderOptions(const RecorderOptions&);
@@ -275,19 +273,22 @@ private:
     void registerDevice(sk_sp<Device>);
     void deregisterDevice(const Device*);
 
+    SkCanvas* makeCaptureCanvas(SkCanvas*) override;
+
     sk_sp<SharedContext> fSharedContext;
     ResourceProvider* fResourceProvider; // May point to the Context's resource provider
     std::unique_ptr<ResourceProvider> fOwnedResourceProvider; // May be null
-    std::unique_ptr<RuntimeEffectDictionary> fRuntimeEffectDict;
+
+    sk_sp<RuntimeEffectDictionary> fRuntimeEffectDict;
 
     // NOTE: These are stored by pointer to allow them to be forward declared.
     std::unique_ptr<TaskList> fRootTaskList;
     // Aggregated one-time uploads that preceed all tasks in the root task list.
     std::unique_ptr<UploadList> fRootUploads;
 
-    std::unique_ptr<TextureDataCache> fTextureDataCache;
     std::unique_ptr<DrawBufferManager> fDrawBufferManager;
     std::unique_ptr<UploadBufferManager> fUploadBufferManager;
+    sk_sp<FloatStorageManager> fFloatStorageManager;
     std::unique_ptr<ProxyReadCountMap> fProxyReadCounts;
 
     // Iterating over tracked devices in flushTrackedDevices() needs to be re-entrant and support
@@ -322,6 +323,14 @@ private:
     // For testing use only -- the Context used to create this Recorder
     Context* fContext = nullptr;
 #endif
+
+#if defined(SK_DUMP_TASKS)
+    // Traverses and dumps the task list at Recorder::snap()
+    void dumpTasks(TaskList*) const;
+
+    // Log of all callers of RecorderPriv::flushTrackedDevices
+    SkTDArray<const char*> fFlushSources;
+#endif
 };
 
 } // namespace skgpu::graphite

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

@@ -68,12 +68,9 @@ private:
 
     Recording(uint32_t uniqueID,
               uint32_t recorderID,
-              std::unordered_set<sk_sp<TextureProxy>, ProxyHash>&& nonVolatileLazyProxies,
-              std::unordered_set<sk_sp<TextureProxy>, ProxyHash>&& volatileLazyProxies,
               std::unique_ptr<LazyProxyData> targetProxyData,
               skia_private::TArray<sk_sp<RefCntedCallback>>&& finishedProcs);
 
-    bool addCommands(CommandBuffer*, ResourceProvider*);
     void addResourceRef(sk_sp<Resource>);
 
     // Used to verify ordering if recorder ID is not SK_InvalidGenID

package/cpp/skia/include/gpu/graphite/mtl/MtlBackendContext.h

@@ -8,10 +8,12 @@
 #ifndef skgpu_graphite_MtlBackendContext_DEFINED
 #define skgpu_graphite_MtlBackendContext_DEFINED
 
+#include "include/gpu/graphite/Context.h"
 #include "include/ports/SkCFObject.h"
 #include "include/private/base/SkAPI.h"
 
 #import <CoreFoundation/CoreFoundation.h>
+#include <memory>
 
 namespace skgpu::graphite {
 

package/cpp/skia/include/gpu/graphite/precompile/PaintOptions.h

@@ -32,7 +32,6 @@ enum class TextureFormat : uint8_t;
 class KeyContext;
 class PaintOptionsPriv;
 class PaintParamsKeyBuilder;
-class PipelineDataGatherer;
 struct RenderPassDesc;
 class UniquePaintParamsID;
 
@@ -119,6 +118,9 @@ public:
     SkSpan<const SkBlendMode> getBlendModes() const {
         return SkSpan<const SkBlendMode>(fBlendModeOptions.data(), fBlendModeOptions.size());
     }
+    void addBlendMode(SkBlendMode bm) {
+        fBlendModeOptions.push_back(bm);
+    }
 
     /** Sets the blender options used when generating precompilation combinations.
 
@@ -155,9 +157,6 @@ private:
     friend class PrecompileMaskFilter;  // for ProcessCombination access
 
     void addColorFilter(sk_sp<PrecompileColorFilter> cf);
-    void addBlendMode(SkBlendMode bm) {
-        fBlendModeOptions.push_back(bm);
-    }
 
     void setClipShaders(SkSpan<const sk_sp<PrecompileShader>> clipShaders);
 
@@ -174,8 +173,6 @@ private:
     // 'desiredCombination' must be less than the result of the numCombinations call
     void createKey(const KeyContext&,
                    TextureFormat,
-                   PaintParamsKeyBuilder*,
-                   PipelineDataGatherer*,
                    int desiredCombination,
                    bool addPrimitiveBlender,
                    bool addAnalyticClip,
@@ -188,7 +185,6 @@ private:
                                const RenderPassDesc&)> ProcessCombination;
 
     void buildCombinations(const KeyContext&,
-                           PipelineDataGatherer*,
                            DrawTypeFlags,
                            bool addPrimitiveBlender,
                            Coverage,