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

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

@@ -18,70 +18,115 @@ struct SkISize;
 
 namespace skgpu::graphite {
 
-class TextureInfoData;
+enum class TextureFormat : uint8_t;
 
+/**
+ * TextureInfo is a backend-agnostic wrapper around the properties of a texture, sans dimensions.
+ * It is designed this way to be compilable w/o bringing in a specific backend's build files, and
+ * without requiring heap allocations of virtual types.
+ */
 class SK_API TextureInfo {
+private:
+    class Data;
+    friend class MtlTextureInfo;
+    friend class DawnTextureInfo;
+    friend class VulkanTextureInfo;
+
+    // Size is the largest of the Data subclasses assuming a 64-bit compiler.
+    inline constexpr static size_t kMaxSubclassSize = 112;
+    using AnyTextureInfoData = SkAnySubclass<Data, kMaxSubclassSize>;
+
+    // Base properties for all backend-specific properties. Clients managing textures directly
+    // should use the public subclasses of Data directly, e.g. MtlTextureInfo/DawnTextureInfo.
+    //
+    // Each backend subclass must expose to TextureInfo[Priv]:
+    //   static constexpr BackendApi kBackend;
+    //   Protected isProtected() const;
+    //   TextureFormat viewFormat() const;
+    //   bool serialize(SkWStream*) const;
+    //   bool deserialize(SkStream*);
+    class Data {
+    public:
+        virtual ~Data() = default;
+
+        Data(uint32_t sampleCount, skgpu::Mipmapped mipmapped)
+                : fSampleCount(sampleCount)
+                , fMipmapped(mipmapped) {}
+
+        Data() = default;
+        Data(const Data&) = default;
+
+        Data& operator=(const Data&) = default;
+
+        // NOTE: These fields are accessible via the backend-specific subclasses.
+        uint32_t fSampleCount = 1;
+        Mipmapped fMipmapped = Mipmapped::kNo;
+
+    private:
+        friend class TextureInfo;
+        friend class TextureInfoPriv;
+
+        virtual SkString toBackendString() const = 0;
+
+        virtual void copyTo(AnyTextureInfoData&) const = 0;
+        // Passed in TextureInfo will have data of the same backend type and subclass, and
+        // base properties of Data have already been checked for equality/compatibility.
+        virtual bool isCompatible(const TextureInfo& that, bool requireExact) const = 0;
+    };
+
 public:
-    TextureInfo();
-    ~TextureInfo();
+    TextureInfo() = default;
+    ~TextureInfo() = default;
+
     TextureInfo(const TextureInfo&);
     TextureInfo& operator=(const TextureInfo&);
 
-    bool operator==(const TextureInfo&) const;
+    bool operator==(const TextureInfo& that) const {
+        return this->isCompatible(that, /*requireExact=*/true);
+    }
     bool operator!=(const TextureInfo& that) const { return !(*this == that); }
 
-    bool isValid() const { return fValid; }
-    BackendApi backend() const { return fBackend; }
+    bool isValid() const { return fData.has_value(); }
+    BackendApi backend() const {
+        SkASSERT(fData.has_value() || fBackend == BackendApi::kUnsupported);
+        return fBackend;
+    }
 
-    uint32_t numSamples() const { return fSampleCount; }
-    Mipmapped mipmapped() const { return fMipmapped; }
+    uint32_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; }
-    SkTextureCompressionType compressionType() const;
-    bool isMemoryless() const;
 
-    bool isCompatible(const TextureInfo& that) const;
+    // 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.
+    bool canBeFulfilledBy(const TextureInfo& that) const {
+        return this->isCompatible(that, /*requireExact=*/false);
+    }
+
     // Return a string containing the full description of this TextureInfo.
     SkString toString() const;
-    // Return a string containing only the info relevant for its use as a RenderPass attachment.
-    SkString toRPAttachmentString() const;
 
 private:
-    friend class TextureInfoData;
     friend class TextureInfoPriv;
 
-    // Size determined by looking at the TextureInfoData subclasses, then guessing-and-checking.
-    // Compiler will complain if this is too small - in that case, just increase the number.
-    inline constexpr static size_t kMaxSubclassSize = 112;
-    using AnyTextureInfoData = SkAnySubclass<TextureInfoData, kMaxSubclassSize>;
-
-    template <typename SomeTextureInfoData>
-    TextureInfo(BackendApi backend,
-                uint32_t sampleCount,
-                skgpu::Mipmapped mipped,
-                skgpu::Protected isProtected,
-                const SomeTextureInfoData& textureInfoData)
-            : fBackend(backend)
-            , fValid(true)
-            , fSampleCount(sampleCount)
-            , fMipmapped(mipped)
-            , fProtected(isProtected) {
-        fTextureInfoData.emplace<SomeTextureInfoData>(textureInfoData);
+    template <typename BackendTextureData,
+              std::enable_if_t<std::is_base_of_v<Data, BackendTextureData>, bool> = true>
+    explicit TextureInfo(const BackendTextureData& data)
+            : fBackend(BackendTextureData::kBackend)
+            , fViewFormat(data.viewFormat())
+            , fProtected(data.isProtected()) {
+        fData.emplace<BackendTextureData>(data);
     }
 
-    friend size_t ComputeSize(SkISize dimensions, const TextureInfo&);  // for bytesPerPixel
-
-    size_t bytesPerPixel() const;
+    bool isCompatible(const TextureInfo& that, bool requireExact) const;
 
-    BackendApi fBackend = BackendApi::kMock;
-    bool fValid = false;
+    skgpu::BackendApi  fBackend = BackendApi::kUnsupported;
+    AnyTextureInfoData fData;
 
-    uint32_t fSampleCount = 1;
-    Mipmapped fMipmapped = Mipmapped::kNo;
+    // Derived properties from the backend data, cached to avoid a virtual function call
+    TextureFormat fViewFormat;
     Protected fProtected = Protected::kNo;
-
-    AnyTextureInfoData fTextureInfoData;
 };
 
-}  // namespace skgpu::graphite
+} // namespace skgpu::graphite
 
-#endif  //skgpu_graphite_TextureInfo_DEFINED
+#endif // skgpu_graphite_TextureInfo_DEFINED

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

@@ -37,10 +37,15 @@ public:
      * by Mipmapped. This will produce an invalid result (return false from isValid()) if the
      * passed formats' channels don't agree with SkYUVAInfo.
      */
-    YUVABackendTextureInfo(const Recorder*,
-                           const SkYUVAInfo&,
+    YUVABackendTextureInfo(const SkYUVAInfo&,
                            SkSpan<const TextureInfo>,
                            Mipmapped);
+    // DEPRECATED: No more need for a Recorder to construct YUVABackendTextureInfo
+    YUVABackendTextureInfo(Recorder*,
+                           const SkYUVAInfo& yuvaInfo,
+                           SkSpan<const TextureInfo> textures,
+                           Mipmapped mipmapped)
+            : YUVABackendTextureInfo(yuvaInfo, textures, mipmapped) {}
 
     bool operator==(const YUVABackendTextureInfo&) const;
     bool operator!=(const YUVABackendTextureInfo& that) const { return !(*this == that); }
@@ -95,9 +100,13 @@ public:
      * indicated by the SkYUVAInfo. This will produce an invalid result (return false from
      * isValid()) if the passed texture formats' channels don't agree with SkYUVAInfo.
      */
-    YUVABackendTextures(const Recorder*,
-                        const SkYUVAInfo&,
+    YUVABackendTextures(const SkYUVAInfo&,
                         SkSpan<const BackendTexture>);
+    // DEPRECATED: No more need for a Recorder to construct YUVABackendTextureInfo
+    YUVABackendTextures(Recorder*,
+                        const SkYUVAInfo& yuvaInfo,
+                        SkSpan<const BackendTexture> textures)
+            : YUVABackendTextures(yuvaInfo, textures) {}
 
     SkSpan<const BackendTexture> planeTextures() const {
         return SkSpan<const BackendTexture>(fPlaneTextures);

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

@@ -11,8 +11,13 @@
 #include "include/core/SkTypes.h"
 #include "webgpu/webgpu_cpp.h"  // NO_G3_REWRITE
 
+#include <memory>
+
 namespace skgpu::graphite {
 
+class Context;
+struct ContextOptions;
+
 /**
  * WebGPU needs to allow the main thread loop to run to detect GPU progress. Dawn native has a
  * function wgpu::Instance::ProcessEvents, not (currently) present in WebGPU, that can be used to
@@ -63,6 +68,10 @@ struct SK_API DawnBackendContext {
 #endif
 };
 
+namespace ContextFactory {
+SK_API std::unique_ptr<Context> MakeDawn(const DawnBackendContext&, const ContextOptions&);
+} // namespace ContextFactory
+
 } // namespace skgpu::graphite
 
 #endif // skgpu_graphite_DawnBackendContext_DEFINED

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__