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

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

@@ -0,0 +1,166 @@
+/*
+ * 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_DawnTypes_DEFINED
+#define skgpu_graphite_DawnTypes_DEFINED
+
+#include "include/core/SkSize.h"
+#include "include/gpu/graphite/GraphiteTypes.h"
+#include "include/gpu/graphite/TextureInfo.h"
+#include "include/private/base/SkAPI.h"
+
+#include "webgpu/webgpu_cpp.h"  // NO_G3_REWRITE
+
+class SkStream;
+class SkWStream;
+
+namespace skgpu::graphite {
+class BackendTexture;
+
+class SK_API DawnTextureInfo final : public TextureInfo::Data {
+public:
+    // wgpu::TextureDescriptor properties
+    wgpu::TextureFormat fFormat = wgpu::TextureFormat::Undefined;
+    // `fViewFormat` for multiplanar formats corresponds to the plane TextureView's format.
+    wgpu::TextureFormat fViewFormat = wgpu::TextureFormat::Undefined;
+    wgpu::TextureUsage fUsage = wgpu::TextureUsage::None;
+    // TODO(b/308944094): Migrate aspect information to BackendTextureViews.
+    wgpu::TextureAspect fAspect = wgpu::TextureAspect::All;
+    uint32_t fSlice = 0;
+
+#if !defined(__EMSCRIPTEN__)
+    // The descriptor of the YCbCr info (if any) for this texture. Dawn's YCbCr
+    // sampling will be used for this texture if this info is set. Setting the
+    // info is supported only on Android and only if using Vulkan as the
+    // underlying GPU driver.
+    wgpu::YCbCrVkDescriptor fYcbcrVkDescriptor = {};
+#endif
+
+    wgpu::TextureFormat getViewFormat() const {
+        return fViewFormat != wgpu::TextureFormat::Undefined ? fViewFormat : fFormat;
+    }
+
+    DawnTextureInfo() = default;
+
+    DawnTextureInfo(WGPUTexture texture);
+
+    DawnTextureInfo(uint32_t sampleCount,
+                    Mipmapped mipmapped,
+                    wgpu::TextureFormat format,
+                    wgpu::TextureUsage usage,
+                    wgpu::TextureAspect aspect)
+            : DawnTextureInfo(sampleCount,
+                              mipmapped,
+                              /*format=*/format,
+                              /*viewFormat=*/format,
+                              usage,
+                              aspect,
+                              /*slice=*/0) {}
+
+    DawnTextureInfo(uint32_t sampleCount,
+                    Mipmapped mipmapped,
+                    wgpu::TextureFormat format,
+                    wgpu::TextureFormat viewFormat,
+                    wgpu::TextureUsage usage,
+                    wgpu::TextureAspect aspect,
+                    uint32_t slice)
+            : Data(sampleCount, mipmapped)
+            , fFormat(format)
+            , fViewFormat(viewFormat)
+            , fUsage(usage)
+            , fAspect(aspect)
+            , fSlice(slice) {}
+
+#if !defined(__EMSCRIPTEN__)
+    DawnTextureInfo(uint32_t sampleCount,
+                    Mipmapped mipmapped,
+                    wgpu::TextureFormat format,
+                    wgpu::TextureFormat viewFormat,
+                    wgpu::TextureUsage usage,
+                    wgpu::TextureAspect aspect,
+                    uint32_t slice,
+                    wgpu::YCbCrVkDescriptor ycbcrVkDescriptor)
+            : Data(sampleCount, mipmapped)
+            , fFormat(format)
+            , fViewFormat(viewFormat)
+            , fUsage(usage)
+            , fAspect(aspect)
+            , fSlice(slice)
+            , fYcbcrVkDescriptor(ycbcrVkDescriptor) {}
+#endif
+
+private:
+    friend class TextureInfo;
+    friend class TextureInfoPriv;
+
+    // Non-virtual template API for TextureInfo::Data accessed directly when backend type is known.
+    static constexpr skgpu::BackendApi kBackend = skgpu::BackendApi::kDawn;
+
+    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;
+
+    void copyTo(TextureInfo::AnyTextureInfoData& dstData) const override {
+        dstData.emplace<DawnTextureInfo>(*this);
+    }
+    bool isCompatible(const TextureInfo& that, bool requireExact) const override;
+};
+
+namespace TextureInfos {
+SK_API TextureInfo MakeDawn(const DawnTextureInfo& dawnInfo);
+
+SK_API bool GetDawnTextureInfo(const TextureInfo&, DawnTextureInfo*);
+}  // namespace TextureInfos
+
+namespace BackendTextures {
+// Create a BackendTexture from a WGPUTexture. Texture info will be queried from the texture.
+//
+// This is the recommended way of specifying a BackendTexture for Dawn. See the note below on
+// the constructor that takes a WGPUTextureView for a fuller explanation.
+//
+// The BackendTexture will not call retain or release on the passed in WGPUTexture. Thus, the
+// client must keep the WGPUTexture valid until they are no longer using the BackendTexture.
+// However, any SkImage or SkSurface that wraps the BackendTexture *will* retain and release
+// the WGPUTexture.
+SK_API BackendTexture MakeDawn(WGPUTexture);
+
+// Create a BackendTexture from a WGPUTexture. Texture planeDimensions, plane aspect and
+// info have to be provided. This is intended to be used only when accessing a plane
+// of a WGPUTexture.
+//
+// The BackendTexture will not call retain or release on the passed in WGPUTexture. Thus, the
+// client must keep the WGPUTexture valid until they are no longer using the BackendTexture.
+// However, any SkImage or SkSurface that wraps the BackendTexture *will* retain and release
+// the WGPUTexture.
+SK_API BackendTexture MakeDawn(SkISize planeDimensions, const DawnTextureInfo&, WGPUTexture);
+
+// Create a BackendTexture from a WGPUTextureView. Texture dimensions and
+// info have to be provided.
+//
+// Using a WGPUTextureView rather than a WGPUTexture is less effecient for operations that
+// require buffer transfers to or from the texture (e.g. methods on graphite::Context that read
+// pixels or SkSurface::writePixels). In such cases an intermediate copy to or from a
+// WGPUTexture is required. Thus, it is recommended to use this functionality only for cases
+// where a WGPUTexture is unavailable, in particular when using wgpu::SwapChain.
+//
+// The BackendTexture will not call retain or release on the passed in WGPUTextureView. Thus,
+// the client must keep the WGPUTextureView valid until they are no longer using the
+// BackendTexture. However, any SkImage or SkSurface that wraps the BackendTexture *will* retain
+// and release the WGPUTextureView.
+SK_API BackendTexture MakeDawn(SkISize dimensions,
+                               const DawnTextureInfo& info,
+                               WGPUTextureView textureView);
+}  // namespace BackendTextures
+
+}  // namespace skgpu::graphite
+
+#endif // skgpu_graphite_DawnTypes_DEFINED

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

@@ -1,147 +1,9 @@
 /*
- * Copyright 2022 Google LLC.
+ * Copyright 2022 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_DawnTypes_DEFINED
-#define skgpu_graphite_DawnTypes_DEFINED
-
-#include "include/core/SkSize.h"
-#include "include/gpu/graphite/GraphiteTypes.h"
-#include "include/private/base/SkAPI.h"
-
-#include "webgpu/webgpu_cpp.h"  // NO_G3_REWRITE
-
-namespace skgpu::graphite {
-class BackendTexture;
-class TextureInfo;
-
-struct DawnTextureInfo {
-    uint32_t fSampleCount = 1;
-    Mipmapped fMipmapped = Mipmapped::kNo;
-
-    // wgpu::TextureDescriptor properties
-    wgpu::TextureFormat fFormat = wgpu::TextureFormat::Undefined;
-    // `fViewFormat` for multiplanar formats corresponds to the plane TextureView's format.
-    wgpu::TextureFormat fViewFormat = wgpu::TextureFormat::Undefined;
-    wgpu::TextureUsage fUsage = wgpu::TextureUsage::None;
-    // TODO(b/308944094): Migrate aspect information to BackendTextureViews.
-    wgpu::TextureAspect fAspect = wgpu::TextureAspect::All;
-    uint32_t fSlice = 0;
-
-#if !defined(__EMSCRIPTEN__)
-    // The descriptor of the YCbCr info (if any) for this texture. Dawn's YCbCr
-    // sampling will be used for this texture if this info is set. Setting the
-    // info is supported only on Android and only if using Vulkan as the
-    // underlying GPU driver.
-    wgpu::YCbCrVkDescriptor fYcbcrVkDescriptor = {};
-#endif
-
-    wgpu::TextureFormat getViewFormat() const {
-        return fViewFormat != wgpu::TextureFormat::Undefined ? fViewFormat : fFormat;
-    }
-
-    DawnTextureInfo() = default;
-
-    DawnTextureInfo(uint32_t sampleCount,
-                    Mipmapped mipmapped,
-                    wgpu::TextureFormat format,
-                    wgpu::TextureUsage usage,
-                    wgpu::TextureAspect aspect)
-            : DawnTextureInfo(sampleCount,
-                              mipmapped,
-                              /*format=*/format,
-                              /*viewFormat=*/format,
-                              usage,
-                              aspect,
-                              /*slice=*/0) {}
-
-    DawnTextureInfo(uint32_t sampleCount,
-                    Mipmapped mipmapped,
-                    wgpu::TextureFormat format,
-                    wgpu::TextureFormat viewFormat,
-                    wgpu::TextureUsage usage,
-                    wgpu::TextureAspect aspect,
-                    uint32_t slice)
-            : fSampleCount(sampleCount)
-            , fMipmapped(mipmapped)
-            , fFormat(format)
-            , fViewFormat(viewFormat)
-            , fUsage(usage)
-            , fAspect(aspect)
-            , fSlice(slice) {}
-
-#if !defined(__EMSCRIPTEN__)
-    DawnTextureInfo(uint32_t sampleCount,
-                    Mipmapped mipmapped,
-                    wgpu::TextureFormat format,
-                    wgpu::TextureFormat viewFormat,
-                    wgpu::TextureUsage usage,
-                    wgpu::TextureAspect aspect,
-                    uint32_t slice,
-                    wgpu::YCbCrVkDescriptor ycbcrVkDescriptor)
-            : fSampleCount(sampleCount)
-            , fMipmapped(mipmapped)
-            , fFormat(format)
-            , fViewFormat(viewFormat)
-            , fUsage(usage)
-            , fAspect(aspect)
-            , fSlice(slice)
-            , fYcbcrVkDescriptor(ycbcrVkDescriptor) {}
-#endif
-};
-
-namespace TextureInfos {
-SK_API TextureInfo MakeDawn(const DawnTextureInfo& dawnInfo);
-
-SK_API bool GetDawnTextureInfo(const TextureInfo&, DawnTextureInfo*);
-}  // namespace TextureInfos
-
-namespace BackendTextures {
-// Create a BackendTexture from a WGPUTexture. Texture info will be queried from the texture.
-//
-// This is the recommended way of specifying a BackendTexture for Dawn. See the note below on
-// the constructor that takes a WGPUTextureView for a fuller explanation.
-//
-// The BackendTexture will not call retain or release on the passed in WGPUTexture. Thus, the
-// client must keep the WGPUTexture valid until they are no longer using the BackendTexture.
-// However, any SkImage or SkSurface that wraps the BackendTexture *will* retain and release
-// the WGPUTexture.
-SK_API BackendTexture MakeDawn(WGPUTexture);
-
-// Create a BackendTexture from a WGPUTexture. Texture planeDimensions, plane aspect and
-// info have to be provided. This is intended to be used only when accessing a plane
-// of a WGPUTexture.
-//
-// The BackendTexture will not call retain or release on the passed in WGPUTexture. Thus, the
-// client must keep the WGPUTexture valid until they are no longer using the BackendTexture.
-// However, any SkImage or SkSurface that wraps the BackendTexture *will* retain and release
-// the WGPUTexture.
-SK_API BackendTexture MakeDawn(SkISize planeDimensions, const DawnTextureInfo&, WGPUTexture);
-
-// Create a BackendTexture from a WGPUTextureView. Texture dimensions and
-// info have to be provided.
-//
-// Using a WGPUTextureView rather than a WGPUTexture is less effecient for operations that
-// require buffer transfers to or from the texture (e.g. methods on graphite::Context that read
-// pixels or SkSurface::writePixels). In such cases an intermediate copy to or from a
-// WGPUTexture is required. Thus, it is recommended to use this functionality only for cases
-// where a WGPUTexture is unavailable, in particular when using wgpu::SwapChain.
-//
-// The BackendTexture will not call retain or release on the passed in WGPUTextureView. Thus,
-// the client must keep the WGPUTextureView valid until they are no longer using the
-// BackendTexture. However, any SkImage or SkSurface that wraps the BackendTexture *will* retain
-// and release the WGPUTextureView.
-SK_API BackendTexture MakeDawn(SkISize dimensions,
-                               const DawnTextureInfo& info,
-                               WGPUTextureView textureView);
-
-}  // namespace BackendTextures
-
-}  // namespace skgpu::graphite
-
-#endif // skgpu_graphite_DawnTypes_DEFINED
-
-
+// DEPRECRATED: DawnTypes.h will be removed in the future, please include DawnGraphiteTypes.h
+#include "include/gpu/graphite/dawn/DawnGraphiteTypes.h"

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

@@ -5,24 +5,5 @@
  * found in the LICENSE file.
  */
 
-#ifndef skgpu_graphite_DawnUtils_DEFINED
-#define skgpu_graphite_DawnUtils_DEFINED
-
-#include <memory>
-
-#include "include/private/base/SkAPI.h"
-
-namespace skgpu::graphite {
-
-class Context;
-struct ContextOptions;
-struct DawnBackendContext;
-
-namespace ContextFactory {
-SK_API std::unique_ptr<Context> MakeDawn(const DawnBackendContext&, const ContextOptions&);
-} // namespace ContextFactory
-
-} // namespace skgpu::graphite
-
-
-#endif // skgpu_graphite_DawnUtils_DEFINED
+// DEPRECRATED: DawnUtils.h will be removed in the future, please include DawnBackendContext.h
+#include "include/gpu/graphite/dawn/DawnBackendContext.h"

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

@@ -23,6 +23,10 @@ struct SK_API MtlBackendContext {
     sk_cfp<CFTypeRef> fQueue;
 };
 
+namespace ContextFactory {
+SK_API std::unique_ptr<Context> MakeMetal(const MtlBackendContext&, const ContextOptions&);
+} // namespace ContextFactory
+
 } // namespace skgpu::graphite
 
 #endif // skgpu_graphite_MtlBackendContext_DEFINED

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

@@ -13,18 +13,21 @@
 #include "include/core/SkTypes.h"
 
 #include "include/gpu/graphite/GraphiteTypes.h"
-#include "include/gpu/graphite/mtl/MtlGraphiteTypesUtils.h"
+#include "include/gpu/graphite/TextureInfo.h"
+#include "include/gpu/graphite/mtl/MtlGraphiteTypes_cpp.h"
 #include "include/private/base/SkAPI.h"
 
 #import <CoreFoundation/CoreFoundation.h>
 #import <Metal/Metal.h>
 #import <TargetConditionals.h>
 
+class SkStream;
+class SkWStream;
+
 namespace skgpu::graphite {
-struct SK_API MtlTextureInfo {
-    uint32_t fSampleCount = 1;
-    skgpu::Mipmapped fMipmapped = skgpu::Mipmapped::kNo;
 
+class SK_API MtlTextureInfo final : public TextureInfo::Data {
+public:
     MTLPixelFormat fFormat = MTLPixelFormatInvalid;
     MTLTextureUsage fUsage = MTLTextureUsageUnknown;
     MTLStorageMode fStorageMode = MTLStorageModeShared;
@@ -38,13 +41,34 @@ struct SK_API MtlTextureInfo {
                    MTLTextureUsage usage,
                    MTLStorageMode storageMode,
                    bool framebufferOnly)
-            : fSampleCount(sampleCount)
-            , fMipmapped(mipmapped)
+            : Data(sampleCount, mipmapped)
             , fFormat(format)
             , fUsage(usage)
             , fStorageMode(storageMode)
             , fFramebufferOnly(framebufferOnly) {}
+
+private:
+    friend class TextureInfo;
+    friend class TextureInfoPriv;
+
+    // Non-virtual template API for TextureInfo::Data accessed directly when backend type is known.
+    static constexpr skgpu::BackendApi kBackend = skgpu::BackendApi::kMetal;
+
+    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;
+
+    void copyTo(TextureInfo::AnyTextureInfoData& dstData) const override {
+        dstData.emplace<MtlTextureInfo>(*this);
+    }
+    bool isCompatible(const TextureInfo& that, bool requireExact) const override;
 };
+
 }  // namespace skgpu::graphite
 
 #endif  // __OBJC__

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

@@ -1,48 +1,10 @@
 /*
- * Copyright 2024 Google LLC
+ * Copyright 2022 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_MtlGraphiteTypesUtils_DEFINED
-#define skgpu_graphite_MtlGraphiteTypesUtils_DEFINED
-
-#include "include/core/SkTypes.h"
-
-#include "include/gpu/graphite/BackendTexture.h"
-#include "include/gpu/graphite/TextureInfo.h"
-#include "include/private/base/SkAPI.h"
-
-#import <CoreFoundation/CoreFoundation.h>
-
-namespace skgpu::graphite {
-
-struct SK_API MtlTextureInfo;
-
-namespace TextureInfos {
-SK_API TextureInfo MakeMetal(const MtlTextureInfo&);
-SK_API TextureInfo MakeMetal(CFTypeRef mtlTexture);
-
-SK_API bool GetMtlTextureInfo(const TextureInfo&, MtlTextureInfo*);
-}  // namespace TextureInfos
-
-namespace BackendTextures {
-// The BackendTexture will not call retain or release on the passed in CFTypeRef. Thus the
-// client must keep the CFTypeRef valid until they are no longer using the BackendTexture.
-SK_API BackendTexture MakeMetal(SkISize dimensions, CFTypeRef mtlTexture);
-
-SK_API CFTypeRef GetMtlTexture(const BackendTexture&);
-}  // namespace BackendTextures
-
-namespace BackendSemaphores {
-// TODO(b/286088355) Determine creator's responsibility for setting refcnt.
-SK_API BackendSemaphore MakeMetal(CFTypeRef mtlEvent, uint64_t value);
-
-SK_API CFTypeRef GetMtlEvent(const BackendSemaphore&);
-SK_API uint64_t GetMtlValue(const BackendSemaphore&);
-}  // namespace BackendSemaphores
-
-}  // namespace skgpu::graphite
-
-#endif  // skgpu_graphite_MtlGraphiteTypesUtils_DEFINED
+// DEPRECRATED: MtlGraphiteTypesUtils.h will be removed in the future, please include
+// MtlGraphiteTypes_cpp.h
+#include "include/gpu/graphite/mtl/MtlGraphiteTypes_cpp.h"

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

@@ -0,0 +1,50 @@
+/*
+ * 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 skgpu_graphite_MtlGraphiteTypesUtils_DEFINED
+#define skgpu_graphite_MtlGraphiteTypesUtils_DEFINED
+
+#include "include/core/SkTypes.h"
+
+#include "include/gpu/graphite/BackendTexture.h"
+#include "include/gpu/graphite/TextureInfo.h"
+#include "include/private/base/SkAPI.h"
+
+#import <CoreFoundation/CoreFoundation.h>
+
+namespace skgpu::graphite {
+
+// MtlTextureInfo requires compiling with Objective-C, so this header is split to allow invoking
+// the various backend wrapping APIs from a C++-only compilation unit.
+class SK_API MtlTextureInfo;
+
+namespace TextureInfos {
+SK_API TextureInfo MakeMetal(const MtlTextureInfo&);
+SK_API TextureInfo MakeMetal(CFTypeRef mtlTexture);
+
+SK_API bool GetMtlTextureInfo(const TextureInfo&, MtlTextureInfo*);
+}  // namespace TextureInfos
+
+namespace BackendTextures {
+// The BackendTexture will not call retain or release on the passed in CFTypeRef. Thus the
+// client must keep the CFTypeRef valid until they are no longer using the BackendTexture.
+SK_API BackendTexture MakeMetal(SkISize dimensions, CFTypeRef mtlTexture);
+
+SK_API CFTypeRef GetMtlTexture(const BackendTexture&);
+}  // namespace BackendTextures
+
+namespace BackendSemaphores {
+// TODO(b/286088355) Determine creator's responsibility for setting refcnt.
+SK_API BackendSemaphore MakeMetal(CFTypeRef mtlEvent, uint64_t value);
+
+SK_API CFTypeRef GetMtlEvent(const BackendSemaphore&);
+SK_API uint64_t GetMtlValue(const BackendSemaphore&);
+}  // namespace BackendSemaphores
+
+}  // namespace skgpu::graphite
+
+#endif  // skgpu_graphite_MtlGraphiteTypesUtils_DEFINED

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

@@ -5,23 +5,5 @@
  * found in the LICENSE file.
  */
 
-#ifndef skgpu_graphite_MtlGraphiteUtils_DEFINED
-#define skgpu_graphite_MtlGraphiteUtils_DEFINED
-
-#include <memory>
-
-#include "include/private/base/SkAPI.h"
-
-namespace skgpu::graphite {
-
-class Context;
-struct ContextOptions;
-struct MtlBackendContext;
-
-namespace ContextFactory {
-SK_API std::unique_ptr<Context> MakeMetal(const MtlBackendContext&, const ContextOptions&);
-} // namespace ContextFactory
-
-} // namespace skgpu::graphite
-
-#endif // skgpu_graphite_MtlGraphiteUtils_DEFINED
+// DEPRECRATED: MtlGraphiteUtils.h will be removed in the future, please include MtlBackendContext.h
+#include "include/gpu/graphite/mtl/MtlBackendContext.h"

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

@@ -8,12 +8,13 @@
 #ifndef skgpu_graphite_precompile_Precompile_DEFINED
 #define skgpu_graphite_precompile_Precompile_DEFINED
 
+#include "include/core/SkColorSpace.h"
+#include "include/core/SkColorType.h"
 #include "include/core/SkSpan.h"
 #include "include/gpu/graphite/GraphiteTypes.h"
 
 namespace skgpu::graphite {
 
-class Context;
 class PaintOptions;
 class PrecompileContext;
 
@@ -23,9 +24,18 @@ class PrecompileContext;
  *  a pipeline.
  */
 struct SK_API RenderPassProperties {
-    DepthStencilFlags fDSFlags      = DepthStencilFlags::kNone;
-    SkColorType       fDstCT        = kRGBA_8888_SkColorType;
-    bool              fRequiresMSAA = false;
+    bool operator==(const RenderPassProperties& other) const {
+        return fDSFlags == other.fDSFlags &&
+               fDstCT == other.fDstCT &&
+               fRequiresMSAA == other.fRequiresMSAA &&
+               SkColorSpace::Equals(fDstCS.get(), other.fDstCS.get());
+    }
+    bool operator!= (const RenderPassProperties& other) const { return !(*this == other); }
+
+    DepthStencilFlags   fDSFlags      = DepthStencilFlags::kNone;
+    SkColorType         fDstCT        = kRGBA_8888_SkColorType;
+    sk_sp<SkColorSpace> fDstCS        = nullptr;
+    bool                fRequiresMSAA = false;
 };
 
 /**

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

@@ -11,6 +11,8 @@
 #include "include/gpu/graphite/precompile/PrecompileBase.h"
 
 #include "include/core/SkBlendMode.h"
+#include "include/core/SkImageInfo.h"
+#include "include/effects/SkGradientShader.h"
 
 class SkColorSpace;
 
@@ -109,11 +111,13 @@ namespace PrecompileShaders {
     // time this entry point allows the equivalent precompilation program structure to be created.
     // Note that this factory is for non-YUV SkImages, the YUVImage factory (below) should be used
     // to represent the shading and sampling required for YUV images.
-    SK_API sk_sp<PrecompileShader> Image();
+    SK_API sk_sp<PrecompileShader> Image(SkSpan<const SkColorInfo> = {},
+                                         SkSpan<const SkTileMode> = {});
     // As with the above Image call, raw ImageShaders are usually created via an
     // SkImage::makeRawShader call. The RawImage call allows the equivalent precompilation
     // program structure to be created without needing the SkImage.
-    SK_API sk_sp<PrecompileShader> RawImage();
+    SK_API sk_sp<PrecompileShader> RawImage(SkSpan<const SkColorInfo> = {},
+                                            SkSpan<const SkTileMode> = {});
 
     // In the main Skia API, the specifics of the SkImage used for the SkImage::makeShader call
     // can determine whether normal or YUV sampling is required. This entry point allows clients
@@ -126,10 +130,14 @@ namespace PrecompileShaders {
     SK_API sk_sp<PrecompileShader> MakeTurbulence();
 
     // --- This block of four matches all the factories in SkGradientShader (SkGradientShader.h)
-    SK_API sk_sp<PrecompileShader> LinearGradient();
-    SK_API sk_sp<PrecompileShader> RadialGradient();
-    SK_API sk_sp<PrecompileShader> TwoPointConicalGradient();
-    SK_API sk_sp<PrecompileShader> SweepGradient();
+    SK_API sk_sp<PrecompileShader> LinearGradient(
+            SkGradientShader::Interpolation = SkGradientShader::Interpolation());
+    SK_API sk_sp<PrecompileShader> RadialGradient(
+            SkGradientShader::Interpolation = SkGradientShader::Interpolation());
+    SK_API sk_sp<PrecompileShader> TwoPointConicalGradient(
+            SkGradientShader::Interpolation = SkGradientShader::Interpolation());
+    SK_API sk_sp<PrecompileShader> SweepGradient(
+            SkGradientShader::Interpolation = SkGradientShader::Interpolation());
 
     // Normally, SkPicture shaders are only created via SkPicture::makeShader. Since the
     // SkPicture to be drawn, most likely, won't be available at precompilation time, this

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

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2022 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_VulkanGraphiteUtils_DEFINED
+#define skgpu_graphite_VulkanGraphiteUtils_DEFINED
+
+#include <memory>
+
+#include "include/private/base/SkAPI.h"
+
+// NOTE: Because there is already a VulkanBackendContext header shared between Ganesh and Graphite,
+// this is named VulkanGraphiteContext.h to supply just the factory function (differing from the
+// public headers exposed by other backends).
+namespace skgpu { struct VulkanBackendContext; }
+
+namespace skgpu::graphite {
+
+class Context;
+struct ContextOptions;
+
+namespace ContextFactory {
+SK_API std::unique_ptr<Context> MakeVulkan(const VulkanBackendContext&, const ContextOptions&);
+} // namespace ContextFactory
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_VulkanGraphiteUtils_DEFINED