@shopify/react-native-skia 2.4.6 → 2.4.14

package/cpp/skia/include/docs/SkXPSDocument.h

@@ -15,13 +15,29 @@
 #include "include/core/SkDocument.h"
 
 struct IXpsOMObjectFactory;
+class SKWStream;
+class SkPixmap;
 
 namespace SkXPS {
 
+using EncodePngCallback = bool (*)(SkWStream* dst, const SkPixmap& src);
+
+struct Options {
+    float dpi = SK_ScalarDefaultRasterDPI;
+
+    /** Clients can provide a way to encode png. */
+    EncodePngCallback pngEncoder = nullptr;
+
+    /** Skia's XPS support depends on having a png encoder registered to handle
+     *  XPS image brushes. Clients that create XPS documents without images may
+     *  set `allowNoPngs` to true to acknowledge this.
+     */
+    bool allowNoPngs = false;
+};
+
 SK_API sk_sp<SkDocument> MakeDocument(SkWStream* stream,
                                       IXpsOMObjectFactory* xpsFactory,
-                                      SkScalar dpi = SK_ScalarDefaultRasterDPI);
-
+                                      Options opts);
 }  // namespace SkXPS
 #endif  // SK_BUILD_FOR_WIN
 #endif  // SkXPSDocument_DEFINED

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

@@ -189,6 +189,7 @@ public:
     class SK_API ChildPtr {
     public:
         ChildPtr() = default;
+        // Intentionally don't declare these to be explicit for convenience.
         ChildPtr(sk_sp<SkShader> s) : fChild(std::move(s)) {}
         ChildPtr(sk_sp<SkColorFilter> cf) : fChild(std::move(cf)) {}
         ChildPtr(sk_sp<SkBlender> b) : fChild(std::move(b)) {}
@@ -433,7 +434,8 @@ public:
             if (!fChild) {
                 SkDEBUGFAIL("Assigning to missing child");
             } else {
-                fOwner->fChildren[(size_t)fChild->index] = std::move(val);
+                fOwner->fChildren[(size_t)fChild->index] =
+                        SkRuntimeEffect::ChildPtr(std::move(val));
             }
             return *this;
         }

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

@@ -14,7 +14,10 @@
 #include "include/core/SkRefCnt.h"
 #include "include/private/base/SkAPI.h"
 
+class GrDirectContext;
+class SkData;
 class SkEncoder;
+class SkImage;
 class SkPixmap;
 class SkWStream;
 
@@ -71,6 +74,21 @@ 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
+ *  can be read before being encoded. For raster-backed images, |ctx| can be nullptr.
+ *  |options| may be used to control the encoding behavior.
+ *
+ *  Returns nullptr if the pixels could not be read or encoding otherwise fails.
+ */
+SK_API sk_sp<SkData> Encode(GrDirectContext* ctx, const SkImage* img, 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.

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

@@ -120,7 +120,7 @@ private:
     }
 
 #ifdef SK_DIRECT3D
-    GrBackendFormat(DXGI_FORMAT dxgiFormat);
+    explicit GrBackendFormat(DXGI_FORMAT dxgiFormat);
 #endif
 
     GrBackendFormat(GrColorType, SkTextureCompressionType, bool isStencilFormat);

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

@@ -31,7 +31,7 @@ public:
 
 class SK_API GrExternalTextureGenerator : public GrTextureGenerator {
 public:
-    GrExternalTextureGenerator(const SkImageInfo& info);
+    explicit GrExternalTextureGenerator(const SkImageInfo& info);
 
     GrSurfaceProxyView onGenerateTexture(GrRecordingContext*,
                                          const SkImageInfo&,

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

@@ -63,12 +63,13 @@ public:
      * use maxSurfaceSampleCountForColorType().
      */
     SK_API bool colorTypeSupportedAsSurface(SkColorType colorType) const {
-        if (kR16G16_unorm_SkColorType == colorType ||
-            kA16_unorm_SkColorType == colorType ||
-            kA16_float_SkColorType == colorType ||
-            kR16G16_float_SkColorType == colorType ||
-            kR16G16B16A16_unorm_SkColorType == colorType ||
-            kGray_8_SkColorType == colorType) {
+        if (colorType == kR16G16_unorm_SkColorType       ||
+            colorType == kA16_unorm_SkColorType          ||
+            colorType == kA16_float_SkColorType          ||
+            colorType == kR16_unorm_SkColorType          ||
+            colorType == kR16G16_float_SkColorType       ||
+            colorType == kR16G16B16A16_unorm_SkColorType ||
+            colorType == kGray_8_SkColorType) {
             return false;
         }
 

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

@@ -20,8 +20,14 @@ class GrBackendRenderTarget;
 namespace skgpu { enum class Mipmapped : bool; }
 
 namespace GrBackendFormats {
+
+// DEPRECATED: Prefer MakeGL(format) for GL_TEXTURE_2D targets and MakeGLExternal() for
+// GL_TEXTURE_EXTERNAL targets.
 SK_API GrBackendFormat MakeGL(GrGLenum format, GrGLenum target);
 
+SK_API GrBackendFormat MakeGL(GrGLenum format); // For GL_TEXTURE_2D textures
+SK_API GrBackendFormat MakeGLExternal();        // For GL_TEXTURE_EXTERNAL textures
+
 SK_API GrGLFormat AsGLFormat(const GrBackendFormat&);
 SK_API GrGLenum AsGLFormatEnum(const GrBackendFormat&);
 }  // namespace GrBackendFormats

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

@@ -19,10 +19,8 @@ public:
     // Creates an invalid backend drawable info.
     GrBackendDrawableInfo() : fIsValid(false) {}
 
-    GrBackendDrawableInfo(const GrVkDrawableInfo& info)
-            : fIsValid(true)
-            , fBackend(GrBackendApi::kVulkan)
-            , fVkInfo(info) {}
+    explicit GrBackendDrawableInfo(const GrVkDrawableInfo& info)
+            : fIsValid(true), fBackend(GrBackendApi::kVulkan), fVkInfo(info) {}
 
     // Returns true if the backend texture has been initialized.
     bool isValid() const { return fIsValid; }

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

@@ -31,6 +31,7 @@
 
 class SkColorInfo;
 class SkSurface;
+class SkCapture;
 enum SkYUVColorSpace : int;
 class SkColorSpace;
 class SkTraceMemoryDump;
@@ -54,6 +55,7 @@ class Buffer;
 class ClientMappedBufferManager;
 class ContextPriv;
 struct ContextOptions;
+class PersistentPipelineStorage;
 class PrecompileContext;
 class QueueManager;
 class ResourceProvider;
@@ -277,6 +279,16 @@ public:
      */
     GpuStatsFlags supportedGpuStats() const;
 
+    /**
+     * If supported by the backend, stores the current pipeline cache data into the
+     * PersistentPipelineStorage-derived object passed into Graphite via
+     * ContextOptions::fPersistentPipelineStorage. The amount stored is limited to 'maxSize'.
+     *
+     * Skia attempts to only call store() on the PersistentPipelineStorage object when the data
+     * is likely to be different from what was last sync'ed.
+     */
+    void syncPipelineData(size_t maxSize = SIZE_MAX);
+
     /*
      * TODO (b/412351769): Do not use startCapture() or endCapture() as the feature is still under
      * development.
@@ -288,7 +300,7 @@ public:
     /*
      * Ends the SkCapture and returns the collected draws and surface creation.
      */
-    void endCapture();
+    sk_sp<SkCapture> endCapture();
 
     // Provides access to functions that aren't part of the public API.
     ContextPriv priv();
@@ -395,6 +407,8 @@ private:
     std::unique_ptr<ClientMappedBufferManager> fMappedBufferManager;
     std::unique_ptr<const skcpu::ContextImpl> fCPUContext;
 
+    PersistentPipelineStorage* fPersistentPipelineStorage;
+
     // In debug builds we guard against improper thread handling. This guard is passed to the
     // ResourceCache for the Context.
     mutable SingleOwner fSingleOwner;

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

@@ -15,6 +15,7 @@
 #include "include/private/base/SkMath.h"
 
 #include <optional>
+#include <string>
 
 class SkData;
 class SkExecutor;
@@ -24,6 +25,7 @@ namespace skgpu { class ShaderErrorHandler; }
 namespace skgpu::graphite {
 
 struct ContextOptionsPriv;
+class PersistentPipelineStorage;
 
 struct SK_API ContextOptions {
     ContextOptions() {}
@@ -141,7 +143,7 @@ struct SK_API ContextOptions {
     /**
      * 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.
+     * internally 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
@@ -149,20 +151,52 @@ struct SK_API ContextOptions {
      */
     std::optional<uint64_t> fVulkanVMALargeHeapBlockSize;
 
-    /** Client-provided context that is passed to client-provided PipelineCallback. */
+    /**
+     * Client-provided context that is passed to the client-provided PipelineCachingCallback
+     * and the (deprecated) 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);
+
+    PipelineCallbackContext fPipelineCallbackContext = nullptr;
+
+    enum class PipelineCacheOp {
+        kAddingPipeline,
+        kPipelineFound,
+    };
+
+    using PipelineCachingCallback = void (*)(PipelineCallbackContext context,
+                                             PipelineCacheOp op,
+                                             const std::string& label,
+                                             uint32_t uniqueKeyHash,
+                                             bool fromPrecompile,
+                                             sk_sp<SkData> pipelineData);
+
+    /**
+     * This member variable allows a client to register a callback that will be invoked
+     * whenever Graphite either adds a Pipeline to its cache (kAddingPipeline op) or finds an
+     * existing Pipeline in its cache (kPipelineFound op). Together this allows clients
+     * to determine the frequency of a given Pipeline's use and which precompiled Pipelines
+     * are unused. The callback is also passed:
+     *    a human-readable label that describes the Pipeline
+     *    a 32-bit hash code that can be used rather than rehashing the provided data
+     *    a Boolean indicating if the Pipeline had been generated via Precompilation
+     * Additionally, for kAddingPipeline ops:
+     *    an SkData version of the Pipeline that a client can take ownership of and serialize.
+     *    Not all Pipelines can be serialized, however, and nullptr will be passed in such cases.
+     *
+     * When provided, the SkData contains all the information Graphite requires to recreate
+     * the Pipeline at a later date, but it is versioned so recreation can fail if it's
+     * incompatible with a newer version of Skia.
+     */
+    PipelineCachingCallback fPipelineCachingCallback = nullptr;
 
     /**
-     *  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.
+     * Deprecated version of the Pipeline callback. This callback is only invoked for
+     * PipelineCacheOp::kAddingPipeline ops and when the key is serializable. It is ignored
+     * if fPipelineCachingCallback is set.
      */
-    PipelineCallbackContext fPipelineCallbackContext = nullptr;
+    using PipelineCallback = void (*)(PipelineCallbackContext context, sk_sp<SkData> pipelineData);
+
     PipelineCallback fPipelineCallback = nullptr;
 
     /**
@@ -189,6 +223,13 @@ struct SK_API ContextOptions {
      */
     SkExecutor* fExecutor = nullptr;
 
+    /**
+     * Allows Graphite to store Pipeline data across Context lifetimes. It is up to the
+     * client to ensure the PersistentPipelineStorage object remains valid throughout the lifetime
+     * of the Context(s).
+     */
+    PersistentPipelineStorage* fPersistentPipelineStorage = nullptr;
+
     /**
      * An experimental flag in development. Behavior and performance is subject to change.
      *

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

@@ -209,6 +209,50 @@ enum class DepthStencilFlags : int {
     kDepthStencil = kDepth | kStencil,
 };
 
+// NOTE: This can be converted to just an `enum class SampleCount {}` once clients are migrated
+// off of writing integer values into backend TextureInfo fields or ContextOptions.
+class SampleCount {
+public:
+    // Do not refer to V directly; use these constants as if SampleCount were a class enum, e.g.
+    // SampleCount::k4.
+    enum V : uint8_t {
+        k1  = 1,
+        k2  = 2,
+        k4  = 4,
+        k8  = 8,
+        k16 = 16
+    };
+
+    constexpr SampleCount() : fValue(k1) {}
+    /*implicit*/ constexpr SampleCount(V v) : fValue(v) {}
+
+    // Behave like an enum
+    constexpr bool operator ==(const SampleCount& o) const { return fValue == o.fValue; }
+    constexpr bool operator  <(const SampleCount& o) const { return fValue  < o.fValue; }
+    constexpr bool operator <=(const SampleCount& o) const { return fValue <= o.fValue; }
+    constexpr bool operator  >(const SampleCount& o) const { return fValue  > o.fValue; }
+    constexpr bool operator >=(const SampleCount& o) const { return fValue >= o.fValue; }
+
+    // This needs to be explicit so that ternaries that return constants mixed with variables aren't
+    // ambiguous; internal code can cast for switch statements.
+    explicit constexpr operator SampleCount::V() const { return fValue; }
+    explicit constexpr operator uint8_t()        const { return (uint8_t) fValue; }
+    explicit constexpr operator unsigned int()   const { return (unsigned int) fValue; }
+
+    // Assist migration from old code that would assign integers to sample count fields that used
+    // to be uint8_t and are now more strictly typed to SampleCount. Asserts if the value doesn't
+    // match a SampleCount value.
+    /*implicit*/ constexpr SampleCount(uint8_t v) : fValue((V) v) {
+        SkASSERT(v == 1 || v == 2 || v == 4 || v == 8 || v == 16);
+    }
+    constexpr SampleCount& operator=(uint8_t sampleCount) {
+        return (*this = SampleCount(sampleCount));
+    }
+
+private:
+    V fValue;
+};
+
 /*
  * This enum allows mapping from a set of observed RenderSteps (e.g., from a GraphicsPipeline
  * printout) to the correct 'drawTypes' parameter needed by the Precompilation API.

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

@@ -31,6 +31,6 @@ enum class LogPriority : int {
     kWarning = 2,
     kDebug = 3,
 };
-};  // namespace skgpu::graphite
+}  // namespace skgpu::graphite
 
 #endif // skgpu_graphite_LogPriority_DEFINED

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

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_PersistentPipelineStorage_DEFINED
+#define skgpu_graphite_PersistentPipelineStorage_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+class SkData;
+
+namespace skgpu::graphite {
+
+/**
+ * Abstract class which can be implemented to allow Graphite to persist Pipeline data across
+ * Context lifetimes
+ */
+class SK_API PersistentPipelineStorage {
+public:
+    virtual ~PersistentPipelineStorage() = default;
+
+    /**
+     * Should return the data that had been previously stored. It should return null if there
+     * is no prior data.
+     */
+    virtual sk_sp<SkData> load() = 0;
+
+    /**
+     * Should persist the provided Pipeline data.
+     */
+    virtual void store(const SkData& data) = 0;
+
+protected:
+    PersistentPipelineStorage() = default;
+    PersistentPipelineStorage(const PersistentPipelineStorage&) = delete;
+    PersistentPipelineStorage& operator=(const PersistentPipelineStorage&) = delete;
+};
+
+}  // namespace skgpu::graphite
+
+#endif // skgpu_graphite_PersistentPipelineStorage_DEFINED

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

@@ -78,7 +78,7 @@ private:
     friend class PrecompileContextPriv;
     friend class Context; // for ctor
 
-    PrecompileContext(sk_sp<SharedContext>);
+    explicit PrecompileContext(sk_sp<SharedContext>);
 
     mutable SingleOwner fSingleOwner;
     sk_sp<SharedContext> fSharedContext;

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

@@ -11,6 +11,7 @@
 #include "include/core/SkCPURecorder.h"
 #include "include/core/SkRecorder.h"
 #include "include/core/SkRefCnt.h"
+#include "include/core/SkSurface.h"
 #include "include/gpu/graphite/GraphiteTypes.h"
 #include "include/gpu/graphite/Recording.h"
 #include "include/private/base/SingleOwner.h"
@@ -54,6 +55,8 @@ class Device;
 class DrawBufferManager;
 class FloatStorageManager;
 class ImageProvider;
+class PaintParamsKeyBuilder;
+class PipelineDataGatherer;
 class ProxyReadCountMap;
 class RecorderPriv;
 class ResourceProvider;
@@ -66,6 +69,8 @@ class UploadList;
 
 struct RecorderOptionsPriv;
 
+using KeyAndDataBuilder = std::pair<PipelineDataGatherer, PaintParamsKeyBuilder>;
+
 struct SK_API RecorderOptions final {
     RecorderOptions();
     RecorderOptions(const RecorderOptions&);
@@ -242,6 +247,8 @@ public:
     const RecorderPriv priv() const;  // NOLINT(readability-const-return-type)
 
 private:
+    static constexpr int kMaxKeyAndDataBuilders = 2;
+
     friend class Context; // For ctor
     friend class Device; // For registering and deregistering Devices;
     friend class RecorderPriv; // for ctor and hidden methods
@@ -274,6 +281,7 @@ private:
     void deregisterDevice(const Device*);
 
     SkCanvas* makeCaptureCanvas(SkCanvas*) override;
+    void createCaptureBreakpoint(SkSurface*) override;
 
     sk_sp<SharedContext> fSharedContext;
     ResourceProvider* fResourceProvider; // May point to the Context's resource provider
@@ -291,6 +299,9 @@ private:
     sk_sp<FloatStorageManager> fFloatStorageManager;
     std::unique_ptr<ProxyReadCountMap> fProxyReadCounts;
 
+    skia_private::STArray<kMaxKeyAndDataBuilders, std::unique_ptr<KeyAndDataBuilder>>
+        fKeyAndDataBuilders;
+
     // Iterating over tracked devices in flushTrackedDevices() needs to be re-entrant and support
     // additions to fTrackedDevices if registerDevice() is triggered by a temporary device during
     // flushing. Removals are handled by setting elements to null; final clean up is handled at the
@@ -319,6 +330,9 @@ private:
 
     skia_private::TArray<sk_sp<RefCntedCallback>> fFinishedProcs;
 
+    // Tracks the flushing state to ensure recursive flushing does not occur.
+    SkDEBUGCODE(bool fIsFlushingTrackedDevices = false;)
+
 #if defined(GPU_TEST_UTILS)
     // For testing use only -- the Context used to create this Recorder
     Context* fContext = nullptr;

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

@@ -9,7 +9,6 @@
 #define skgpu_graphite_TextureInfo_DEFINED
 
 #include "include/core/SkString.h"
-#include "include/core/SkTextureCompressionType.h"
 #include "include/gpu/graphite/GraphiteTypes.h"
 #include "include/private/base/SkAPI.h"
 #include "include/private/base/SkAnySubclass.h"
@@ -43,8 +42,6 @@ private:
     //   static constexpr BackendApi kBackend;
     //   Protected isProtected() const;
     //   TextureFormat viewFormat() const;
-    //   bool serialize(SkWStream*) const;
-    //   bool deserialize(SkStream*);
     class Data {
     public:
         virtual ~Data() = default;
@@ -59,6 +56,10 @@ private:
         Data& operator=(const Data&) = default;
 
         // NOTE: These fields are accessible via the backend-specific subclasses.
+
+        // Must be a valid SampleCount value, or TextureInfo creation will fail to wrap the backend
+        // specific data. This is not strongly typed so that it can be assigned directly from the
+        // backend GPU API's representation, which is often just an integer.
         uint8_t fSampleCount = 1;
         Mipmapped fMipmapped = Mipmapped::kNo;
 
@@ -92,9 +93,13 @@ public:
         return fBackend;
     }
 
-    uint8_t numSamples() const { return fData.has_value() ? fData->fSampleCount : 1; }
-    Mipmapped mipmapped() const { return fData.has_value() ? fData->fMipmapped   : Mipmapped::kNo; }
     Protected isProtected() const { return fProtected; }
+    SampleCount sampleCount() const {
+        return fData.has_value() ? static_cast<SampleCount>(fData->fSampleCount) : SampleCount::k1;
+    }
+    Mipmapped mipmapped() const {
+        return fData.has_value() ? fData->fMipmapped   : Mipmapped::kNo;
+    }
 
     // Return true if `that` describes a texture that is compatible with this info and can validly
     // be used to fulfill a promise image that was created with this TextureInfo.
@@ -114,6 +119,9 @@ private:
             : fBackend(BackendTextureData::kBackend)
             , fViewFormat(data.viewFormat())
             , fProtected(data.isProtected()) {
+        // TextureInfoPriv should not construct a TextureInfo if `data` would fail this assert.
+        SkASSERT(data.fSampleCount == 1 || data.fSampleCount == 2 || data.fSampleCount == 4 ||
+                 data.fSampleCount == 8 || data.fSampleCount == 16);
         fData.emplace<BackendTextureData>(data);
     }
 

package/cpp/skia/include/gpu/graphite/dawn/DawnGraphiteTypes.h

@@ -46,7 +46,7 @@ public:
 
     DawnTextureInfo() = default;
 
-    DawnTextureInfo(WGPUTexture texture);
+    explicit DawnTextureInfo(WGPUTexture texture);
 
     DawnTextureInfo(uint32_t sampleCount,
                     Mipmapped mipmapped,
@@ -103,9 +103,6 @@ private:
     Protected isProtected() const { return Protected::kNo; }
     TextureFormat viewFormat() const;
 
-    bool serialize(SkWStream*) const;
-    bool deserialize(SkStream*);
-
     // Virtual API when the specific backend type is not available.
     SkString toBackendString() const override;
 

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

@@ -34,7 +34,7 @@ public:
     bool fFramebufferOnly = false;
 
     MtlTextureInfo() = default;
-    MtlTextureInfo(CFTypeRef mtlTexture);
+    explicit MtlTextureInfo(CFTypeRef mtlTexture);
     MtlTextureInfo(uint32_t sampleCount,
                    skgpu::Mipmapped mipmapped,
                    MTLPixelFormat format,
@@ -57,9 +57,6 @@ private:
     Protected isProtected() const { return Protected::kNo; }
     TextureFormat viewFormat() const;
 
-    bool serialize(SkWStream*) const;
-    bool deserialize(SkStream*);
-
     // Virtual API when the specific backend type is not available.
     SkString toBackendString() const override;
 

package/cpp/skia/include/gpu/graphite/vk/VulkanGraphiteTypes.h

@@ -13,9 +13,6 @@
 #include "include/gpu/graphite/TextureInfo.h"
 #include "include/gpu/vk/VulkanTypes.h"
 
-class SkStream;
-class SkWStream;
-
 namespace skgpu::graphite {
 
 class SK_API VulkanTextureInfo final : public TextureInfo::Data {
@@ -40,7 +37,7 @@ public:
     VulkanYcbcrConversionInfo fYcbcrConversionInfo;
 
     VulkanTextureInfo() = default;
-    VulkanTextureInfo(uint32_t sampleCount,
+    VulkanTextureInfo(VkSampleCountFlagBits sampleCount,
                       Mipmapped mipmapped,
                       VkImageCreateFlags flags,
                       VkFormat format,
@@ -49,7 +46,7 @@ public:
                       VkSharingMode sharingMode,
                       VkImageAspectFlags aspectMask,
                       VulkanYcbcrConversionInfo ycbcrConversionInfo)
-            : Data(sampleCount, mipmapped)
+            : Data(static_cast<uint8_t>(sampleCount), mipmapped)
             , fFlags(flags)
             , fFormat(format)
             , fImageTiling(imageTiling)
@@ -70,9 +67,6 @@ private:
     }
     TextureFormat viewFormat() const;
 
-    bool serialize(SkWStream*) const;
-    bool deserialize(SkStream*);
-
     // Virtual API when the specific backend type is not available.
     SkString toBackendString() const override;
 

package/cpp/skia/include/gpu/vk/VulkanExtensions.h

@@ -36,7 +36,7 @@ public:
 
     struct Info {
         Info() {}
-        Info(const char* name) : fName(name), fSpecVersion(0) {}
+        explicit Info(const char* name) : fName(name), fSpecVersion(0) {}
 
         SkString fName;
         uint32_t fSpecVersion;