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

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

@@ -0,0 +1,41 @@
+/*
+ * 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 SkPDFJPEGHelpers_DEFINED
+#define SkPDFJPEGHelpers_DEFINED
+
+#include "include/codec/SkJpegDecoder.h"
+#include "include/core/SkData.h"
+#include "include/core/SkRefCnt.h"
+#include "include/docs/SkPDFDocument.h"
+#include "include/encode/SkJpegEncoder.h"
+
+class SkPixmap;
+class SkWStream;
+
+#include <memory>
+
+namespace SkPDF::JPEG {
+inline std::unique_ptr<SkCodec> Decode(sk_sp<SkData> data) {
+    return SkJpegDecoder::Decode(data, nullptr, nullptr);
+}
+
+inline bool Encode(SkWStream* dst, const SkPixmap& src, int quality) {
+    SkJpegEncoder::Options jOpts;
+    jOpts.fQuality = quality;
+    return SkJpegEncoder::Encode(dst, src, jOpts);
+}
+
+inline SkPDF::Metadata MetadataWithCallbacks() {
+    SkPDF::Metadata m;
+    m.jpegDecoder = SkPDF::JPEG::Decode;
+    m.jpegEncoder = SkPDF::JPEG::Encode;
+    return m;
+}
+
+}  // namespace SkPDF::JPEG
+
+#endif

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

@@ -126,6 +126,8 @@ public:
         // don't run the inliner directly, but they still get an inlining pass once they are
         // painted.)
         bool forceUnoptimized = false;
+        // When possible this name will be used to identify the created runtime effect.
+        std::string_view fName;
 
     private:
         friend class SkRuntimeEffect;
@@ -317,7 +319,9 @@ private:
     friend class SkRuntimeEffectPriv;
 
     uint32_t fHash;
-    uint32_t fStableKey;
+    // When not 0, this field holds a StableKey value or a user-defined stable key
+    uint32_t fStableKey = 0;
+    SkString fName;
 
     std::unique_ptr<SkSL::Program> fBaseProgram;
     std::unique_ptr<SkSL::RP::Program> fRPProgram;

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

@@ -38,6 +38,10 @@ public:
     static SkMaskFilter* CreateClip(uint8_t min, uint8_t max);
 
     SkTableMaskFilter() = delete;
+
+private:
+    static void RegisterFlattenables();
+    friend class SkFlattenable;
 };
 
 #endif

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

@@ -17,7 +17,6 @@
 namespace skgpu::graphite {
 
 class BackendTextureData;
-struct VulkanTextureInfo;
 
 class SK_API BackendTexture {
 public:
@@ -61,4 +60,3 @@ private:
 } // namespace skgpu::graphite
 
 #endif // skgpu_graphite_BackendTexture_DEFINED
-

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

@@ -9,12 +9,14 @@
 #define skgpu_graphite_ContextOptions_DEFINED
 
 #include "include/core/SkRefCnt.h"
+#include "include/core/SkSpan.h"
 #include "include/private/base/SkAPI.h"
 #include "include/private/base/SkMath.h"
 
 #include <optional>
 
 class SkData;
+class SkRuntimeEffect;
 namespace skgpu { class ShaderErrorHandler; }
 
 namespace skgpu::graphite {
@@ -136,6 +138,21 @@ struct SK_API ContextOptions {
     PipelineCallbackContext fPipelineCallbackContext = nullptr;
     PipelineCallback fPipelineCallback = nullptr;
 
+    /**
+     * The runtime effects provided here will be registered as user-defined *known* runtime
+     * effects and will be given a stable key. Such runtime effects can then be used in
+     * serialized pipeline keys (c.f. PrecompileContext::precompile).
+     *
+     * Graphite will take a ref on the provided runtime effects and they will persist for as long
+     * as the Context exists. Rather than recreating new SkRuntimeEffects using the same SkSL,
+     * clients should use the existing SkRuntimeEffects provided here.
+     *
+     * Warning: Registering runtime effects here does obligate users to clear out their caches
+     * of serialized pipeline keys if the provided runtime effects ever change in a meaningful way.
+     * This includes adding, removing or reordering the effects provided here.
+     */
+    SkSpan<sk_sp<SkRuntimeEffect>> fUserDefinedKnownRuntimeEffects;
+
     /**
      * Private options that are only meant for testing within Skia's tools.
      */

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

@@ -140,44 +140,47 @@ enum class DepthStencilFlags : int {
  */
 enum DrawTypeFlags : uint16_t {
 
-    kNone             = 0b000000000,
+    kNone             = 0,
 
     // kBitmapText_Mask should be used for the BitmapTextRenderStep[mask] RenderStep
-    kBitmapText_Mask  = 0b00000001,
+    kBitmapText_Mask  = 1 << 0,
     // kBitmapText_LCD should be used for the BitmapTextRenderStep[LCD] RenderStep
-    kBitmapText_LCD   = 0b00000010,
+    kBitmapText_LCD   = 1 << 1,
     // kBitmapText_Color should be used for the BitmapTextRenderStep[color] RenderStep
-    kBitmapText_Color = 0b00000100,
+    kBitmapText_Color = 1 << 2,
     // kSDFText should be used for the SDFTextRenderStep RenderStep
-    kSDFText          = 0b00001000,
+    kSDFText          = 1 << 3,
     // kSDFText_LCD should be used for the SDFTextLCDRenderStep RenderStep
-    kSDFText_LCD      = 0b00010000,
+    kSDFText_LCD      = 1 << 4,
 
     // kDrawVertices should be used to generate Pipelines that use the following RenderSteps:
     //    VerticesRenderStep[*] for:
-    //        [tris], [tris-texCoords], [tris-color], [tris-color-texCoords],
-    //        [tristrips], [tristrips-texCoords], [tristrips-color], [tristrips-color-texCoords]
-    kDrawVertices     = 0b00100000,
+    //        [Tris], [TrisTexCoords], [TrisColor], [TrisColorTexCoords],
+    //        [Tristrips], [TristripsTexCoords], [TristripsColor], [TristripsColorTexCoords]
+    kDrawVertices     = 1 << 5,
+
+    // kCircularArc renders filled circular arcs, with or without the center included, and
+    // stroked circular arcs with butt or round caps that don't include the center point.
+    // It corresponds to the CircularArcRenderStep.
+    kCircularArc      = 1 << 6,
 
     // kSimpleShape should be used to generate Pipelines that use the following RenderSteps:
-    //    AnalyticBlurRenderStep
     //    AnalyticRRectRenderStep
     //    PerEdgeAAQuadRenderStep
-    //    CoverBoundsRenderStep[non-aa-fill]
-    kSimpleShape      = 0b01000000,
+    //    CoverBoundsRenderStep[NonAAFill]
+    kSimpleShape      = 1 << 7,
 
     // kNonSimpleShape should be used to generate Pipelines that use the following RenderSteps:
     //    CoverageMaskRenderStep
-    //    CoverBoundsRenderStep[*] for [inverse-cover], [regular-cover]
+    //    CoverBoundsRenderStep[*] for [InverseCover], [RegularCover]
     //    TessellateStrokeRenderStep
-    //    TessellateWedgesRenderStep[*] for [convex], [evenodd], [winding]
-    //    TessellateCurvesRenderStep[*] for [even-odd], [winding]
-    //    MiddleOutFanRenderStep[*] for [even-odd], [winding]
-    kNonSimpleShape   = 0b10000000,
+    //    TessellateWedgesRenderStep[*] for [Convex], [EvenOdd], [Winding]
+    //    TessellateCurvesRenderStep[*] for [EvenOdd], [Winding]
+    //    MiddleOutFanRenderStep[*] for [EvenOdd], [Winding]
+    kNonSimpleShape   = 1 << 8,
 
     kLast = kNonSimpleShape,
 };
-static constexpr int kDrawTypeFlagsCnt = static_cast<int>(DrawTypeFlags::kLast) + 1;
 
 } // namespace skgpu::graphite
 

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

@@ -14,6 +14,8 @@
 #include <chrono>
 #include <memory>
 
+class SkData;
+
 namespace skgpu::graphite {
 
 class SharedContext;
@@ -32,6 +34,28 @@ public:
      */
     void purgePipelinesNotUsedInMs(std::chrono::milliseconds msNotUsed);
 
+    /**
+     * Emit histograms (using the SK_HISTOGRAM* macros) for Skia's Pipeline usage.
+     */
+    void reportPipelineStats();
+
+    /**
+     * Precompile one specific Pipeline that has been previously serialized. Serialized pipeline
+     * keys can be acquired via the ContextOptions::PipelineCallback.
+     *
+     * @param serializedPipelineKey   serialized Pipeline key.
+     * @return                        true if a Pipeline was created from the key; false otherwise
+     */
+    bool precompile(sk_sp<SkData> serializedPipelineKey);
+
+    /**
+     * Get a human-readable version of a serialized pipeline key.
+     *
+     * @param serializedPipelineKey   serialized Pipeline key.
+     * @return                        A human-readable version of the provided key; "" on failure.
+     */
+    std::string getPipelineLabel(sk_sp<SkData> serializedPipelineKey);
+
     // Provides access to functions that aren't part of the public API.
     PrecompileContextPriv priv();
     const PrecompileContextPriv priv() const;  // NOLINT(readability-const-return-type)

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