@shopify/react-native-skia 2.0.0-next.2 → 2.0.0-next.4

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

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

@@ -13,20 +13,21 @@
 #include "include/gpu/graphite/TextureInfo.h"
 #include "include/gpu/vk/VulkanTypes.h"
 
-namespace skgpu::graphite {
+class SkStream;
+class SkWStream;
 
-struct VulkanTextureInfo {
-    uint32_t fSampleCount = 1;
-    Mipmapped fMipmapped = Mipmapped::kNo;
+namespace skgpu::graphite {
 
+class SK_API VulkanTextureInfo final : public TextureInfo::Data {
+public:
     // VkImageCreateInfo properties
     // Currently the only supported flag is VK_IMAGE_CREATE_PROTECTED_BIT. Any other flag will not
     // be accepted
-    VkImageCreateFlags       fFlags = 0;
-    VkFormat                 fFormat = VK_FORMAT_UNDEFINED;
-    VkImageTiling            fImageTiling = VK_IMAGE_TILING_OPTIMAL;
-    VkImageUsageFlags        fImageUsageFlags = 0;
-    VkSharingMode            fSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+    VkImageCreateFlags fFlags = 0;
+    VkFormat           fFormat = VK_FORMAT_UNDEFINED;
+    VkImageTiling      fImageTiling = VK_IMAGE_TILING_OPTIMAL;
+    VkImageUsageFlags  fImageUsageFlags = 0;
+    VkSharingMode      fSharingMode = VK_SHARING_MODE_EXCLUSIVE;
 
     // Properties related to the image view and sampling. These are less inherent properties of the
     // VkImage but describe how the VkImage should be used within Skia.
@@ -35,8 +36,8 @@ struct VulkanTextureInfo {
     // However, if the VkImage is a Ycbcr format, the client can pass a specific plan here to have
     // Skia directly sample a plane. In that case the client should also pass in a VkFormat that is
     // compatible with the plane as described by the Vulkan spec.
-    VkImageAspectFlags         fAspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
-    VulkanYcbcrConversionInfo  fYcbcrConversionInfo;
+    VkImageAspectFlags        fAspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    VulkanYcbcrConversionInfo fYcbcrConversionInfo;
 
     VulkanTextureInfo() = default;
     VulkanTextureInfo(uint32_t sampleCount,
@@ -48,8 +49,7 @@ struct VulkanTextureInfo {
                       VkSharingMode sharingMode,
                       VkImageAspectFlags aspectMask,
                       VulkanYcbcrConversionInfo ycbcrConversionInfo)
-            : fSampleCount(sampleCount)
-            , fMipmapped(mipmapped)
+            : Data(sampleCount, mipmapped)
             , fFlags(flags)
             , fFormat(format)
             , fImageTiling(imageTiling)
@@ -57,6 +57,29 @@ struct VulkanTextureInfo {
             , fSharingMode(sharingMode)
             , fAspectMask(aspectMask)
             , fYcbcrConversionInfo(ycbcrConversionInfo) {}
+
+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::kVulkan;
+
+    Protected isProtected() const {
+        return fFlags & VK_IMAGE_CREATE_PROTECTED_BIT ? Protected::kYes : 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<VulkanTextureInfo>(*this);
+    }
+    bool isCompatible(const TextureInfo& that, bool requireExact) const override;
 };
 
 namespace TextureInfos {
@@ -78,7 +101,6 @@ namespace BackendSemaphores {
 SK_API BackendSemaphore MakeVulkan(VkSemaphore);
 
 SK_API VkSemaphore GetVkSemaphore(const BackendSemaphore&);
-
 }  // namespace BackendSemaphores
 
 }  // namespace skgpu::graphite

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

@@ -5,24 +5,6 @@
  * found in the LICENSE file.
  */
 
-#ifndef skgpu_graphite_VulkanGraphiteUtils_DEFINED
-#define skgpu_graphite_VulkanGraphiteUtils_DEFINED
-
-#include <memory>
-
-#include "include/private/base/SkAPI.h"
-
-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
+// DEPRECRATED: VulkanGraphiteUtils.h will be removed in the future, please include
+// VulkanGraphiteContext.h
+#include "include/gpu/graphite/vk/VulkanGraphiteContext.h"

package/cpp/skia/include/ports/SkTypeface_fontations.h

@@ -18,4 +18,7 @@
 SK_API sk_sp<SkTypeface> SkTypeface_Make_Fontations(std::unique_ptr<SkStreamAsset> fontData,
                                                     const SkFontArguments& args);
 
+SK_API sk_sp<SkTypeface> SkTypeface_Make_Fontations(sk_sp<SkData> fontData,
+                                                    const SkFontArguments& args);
+
 #endif

package/cpp/skia/include/private/SkJpegMetadataDecoder.h

@@ -86,6 +86,13 @@ public:
     virtual bool findGainmapImage(sk_sp<SkData> baseImageData,
                                   sk_sp<SkData>& outGainmapImagedata,
                                   SkGainmapInfo& outGainmapInfo) = 0;
+
+     /**
+      * Return the first JUMBF superbox, if any, and nullptr otherwise. If |copyData| is false,
+      * then the returned SkData may directly reference the data provided when this object was
+      * created.
+      */
+    virtual sk_sp<SkData> getJUMBFMetadata(bool copyData) const = 0;
 };
 
 #endif

package/cpp/skia/include/private/base/SkAnySubclass.h

@@ -52,6 +52,9 @@ public:
         fValid = false;
     }
 
+    bool has_value() const { return fValid; }
+    explicit operator bool() const { return this->has_value(); }
+
     const Base* get() const {
         SkASSERT(fValid);
         return std::launder(reinterpret_cast<const Base*>(fData));
@@ -65,6 +68,9 @@ public:
     Base* operator->() { return this->get(); }
     const Base* operator->() const { return this->get(); }
 
+    Base& operator*() { return *this->get(); }
+    const Base& operator*() const { return *this->get(); }
+
 private:
     alignas(8) std::byte fData[Size];
     bool fValid = false;