@shopify/react-native-skia 0.1.192 → 0.1.193

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

@@ -8,36 +8,34 @@
 #ifndef skgpu_graphite_Context_DEFINED
 #define skgpu_graphite_Context_DEFINED
 
+#include "include/core/SkImage.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkShader.h"
 #include "include/gpu/graphite/ContextOptions.h"
 #include "include/gpu/graphite/GraphiteTypes.h"
 #include "include/gpu/graphite/Recorder.h"
-#include "include/private/SingleOwner.h"
+#include "include/private/base/SingleOwner.h"
 
+#include <functional>
 #include <memory>
 
 class SkRuntimeEffect;
 
-namespace skgpu { struct VulkanBackendContext; }
-
 namespace skgpu::graphite {
 
 class BackendTexture;
+class Buffer;
+class ClientMappedBufferManager;
 class Context;
 class ContextPriv;
-struct DawnBackendContext;
 class GlobalCache;
-struct MtlBackendContext;
+class PaintOptions;
+class PlotUploadTracker;
 class QueueManager;
 class Recording;
 class ResourceProvider;
 class SharedContext;
-
-#ifdef SK_ENABLE_PRECOMPILE
-class BlenderID;
-class CombinationBuilder;
-#endif
+class TextureProxy;
 
 class SK_API Context final {
 public:
@@ -48,37 +46,30 @@ public:
 
     ~Context();
 
-#ifdef SK_DAWN
-    static std::unique_ptr<Context> MakeDawn(const DawnBackendContext&, const ContextOptions&);
-#endif
-#ifdef SK_METAL
-    static std::unique_ptr<Context> MakeMetal(const MtlBackendContext&, const ContextOptions&);
-#endif
-
-#ifdef SK_VULKAN
-    static std::unique_ptr<Context> MakeVulkan(const VulkanBackendContext&, const ContextOptions&);
-#endif
-
     BackendApi backend() const;
 
     std::unique_ptr<Recorder> makeRecorder(const RecorderOptions& = {});
 
-    void insertRecording(const InsertRecordingInfo&);
-    void submit(SyncToCpu = SyncToCpu::kNo);
+    bool insertRecording(const InsertRecordingInfo&);
+    bool submit(SyncToCpu = SyncToCpu::kNo);
+
+    void asyncReadPixels(const SkImage* image,
+                         const SkColorInfo& dstColorInfo,
+                         const SkIRect& srcRect,
+                         SkImage::ReadPixelsCallback callback,
+                         SkImage::ReadPixelsContext context);
+
+    void asyncReadPixels(const SkSurface* surface,
+                         const SkColorInfo& dstColorInfo,
+                         const SkIRect& srcRect,
+                         SkImage::ReadPixelsCallback callback,
+                         SkImage::ReadPixelsContext context);
 
     /**
      * Checks whether any asynchronous work is complete and if so calls related callbacks.
      */
     void checkAsyncWorkCompletion();
 
-#ifdef SK_ENABLE_PRECOMPILE
-    // TODO: add "ShaderID addUserDefinedShader(sk_sp<SkRuntimeEffect>)" here
-    // TODO: add "ColorFilterID addUserDefinedColorFilter(sk_sp<SkRuntimeEffect>)" here
-    BlenderID addUserDefinedBlender(sk_sp<SkRuntimeEffect>);
-
-    void precompile(CombinationBuilder*);
-#endif
-
     /**
      * Called to delete the passed in BackendTexture. This should only be called if the
      * BackendTexture was created by calling Recorder::createBackendTexture on a Recorder created
@@ -94,21 +85,83 @@ public:
     ContextPriv priv();
     const ContextPriv priv() const;  // NOLINT(readability-const-return-type)
 
+    class ContextID {
+    public:
+        static Context::ContextID Next();
+
+        ContextID() : fID(SK_InvalidUniqueID) {}
+
+        bool operator==(const ContextID& that) const { return fID == that.fID; }
+        bool operator!=(const ContextID& that) const { return !(*this == that); }
+
+        void makeInvalid() { fID = SK_InvalidUniqueID; }
+        bool isValid() const { return fID != SK_InvalidUniqueID; }
+
+    private:
+        constexpr ContextID(uint32_t id) : fID(id) {}
+        uint32_t fID;
+    };
+
+    ContextID contextID() const { return fContextID; }
+
 protected:
-    Context(sk_sp<SharedContext>, std::unique_ptr<QueueManager>);
+    Context(sk_sp<SharedContext>, std::unique_ptr<QueueManager>, const ContextOptions&);
 
 private:
     friend class ContextPriv;
+    friend class ContextCtorAccessor;
 
     SingleOwner* singleOwner() const { return &fSingleOwner; }
 
+    // Must be called in Make() to handle one-time GPU setup operations that can possibly fail and
+    // require Context::Make() to return a nullptr.
+    bool finishInitialization();
+
+    void asyncReadPixels(const TextureProxy* textureProxy,
+                         const SkImageInfo& srcImageInfo,
+                         const SkColorInfo& dstColorInfo,
+                         const SkIRect& srcRect,
+                         SkImage::ReadPixelsCallback callback,
+                         SkImage::ReadPixelsContext context);
+
+    // Inserts a texture to buffer transfer task, used by asyncReadPixels methods
+    struct PixelTransferResult {
+        using ConversionFn = void(void* dst, const void* mappedBuffer);
+        // If null then the transfer could not be performed. Otherwise this buffer will contain
+        // the pixel data when the transfer is complete.
+        sk_sp<Buffer> fTransferBuffer;
+        // RowBytes for transfer buffer data
+        size_t fRowBytes;
+        // If this is null then the transfer buffer will contain the data in the requested
+        // color type. Otherwise, when the transfer is done this must be called to convert
+        // from the transfer buffer's color type to the requested color type.
+        std::function<ConversionFn> fPixelConverter;
+    };
+    PixelTransferResult transferPixels(const TextureProxy*,
+                                       const SkImageInfo& srcImageInfo,
+                                       const SkColorInfo& dstColorInfo,
+                                       const SkIRect& srcRect);
+
     sk_sp<SharedContext> fSharedContext;
     std::unique_ptr<ResourceProvider> fResourceProvider;
     std::unique_ptr<QueueManager> fQueueManager;
+    std::unique_ptr<ClientMappedBufferManager> fMappedBufferManager;
+    std::unique_ptr<PlotUploadTracker> fPlotUploadTracker;
 
     // In debug builds we guard against improper thread handling. This guard is passed to the
     // ResourceCache for the Context.
     mutable SingleOwner fSingleOwner;
+
+#if GRAPHITE_TEST_UTILS
+    // In test builds a Recorder may track the Context that was used to create it.
+    bool fStoreContextRefInRecorder = false;
+    // If this tracking is on, to allow the client to safely delete this Context or its Recorders
+    // in any order we must also track the Recorders created here.
+    std::vector<Recorder*> fTrackedRecorders;
+#endif
+
+    // Needed for MessageBox handling
+    const ContextID fContextID;
 };
 
 } // namespace skgpu::graphite

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

@@ -8,6 +8,8 @@
 #ifndef skgpu_graphite_ContextOptions_DEFINED
 #define skgpu_graphite_ContextOptions_DEFINED
 
+#include "include/private/base/SkAPI.h"
+
 namespace skgpu { class ShaderErrorHandler; }
 
 namespace skgpu::graphite {
@@ -15,6 +17,13 @@ namespace skgpu::graphite {
 struct SK_API ContextOptions {
     ContextOptions() {}
 
+    /**
+     * Disables correctness workarounds that are enabled for particular GPUs, OSes, or drivers.
+     * This does not affect code path choices that are made for perfomance reasons nor does it
+     * override other ContextOption settings.
+     */
+    bool fDisableDriverCorrectnessWorkarounds = false;
+
     /**
      * If present, use this object to report shader compilation failures. If not, report failures
      * via SkDebugf and assert.
@@ -55,18 +64,7 @@ struct SK_API ContextOptions {
      * fGlypheCacheTextureMaximumBytes.
      */
     bool fAllowMultipleGlyphCacheTextures = true;
-
-    /**
-     * If true, then add 1 pixel padding to all glyph masks in the atlas to support bi-lerp
-     * rendering of all glyphs. This must be set to true to use Slugs.
-     */
-    #if defined(SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG) || \
-        defined(SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG_SERIALIZE) || \
-        defined(SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG_STRIKE_SERIALIZE)
-    bool fSupportBilerpFromGlyphAtlas = true;
-    #else
     bool fSupportBilerpFromGlyphAtlas = false;
-    #endif
 
 #if GRAPHITE_TEST_UTILS
     /**
@@ -77,6 +75,12 @@ struct SK_API ContextOptions {
      * Maximum width and height of internal texture atlases.
      */
     int  fMaxTextureAtlasSize = 2048;
+
+    /**
+     * If true, will store a pointer in Recorder that points back to the Context
+     * that created it. Used by readPixels() and other methods that normally require a Context.
+     */
+    bool fStoreContextRefInRecorder = false;
 #endif
 };
 

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

@@ -8,14 +8,18 @@
 #ifndef skgpu_graphite_GraphiteTypes_DEFINED
 #define skgpu_graphite_GraphiteTypes_DEFINED
 
+#include "include/core/SkPoint.h"
 #include "include/core/SkTypes.h"
 #include "include/gpu/GpuTypes.h"
 
 #include <memory>
 
+class SkSurface;
+
 namespace skgpu::graphite {
 
 class Recording;
+class Task;
 
 using GpuFinishedContext = void*;
 using GpuFinishedProc = void (*)(GpuFinishedContext finishedContext, CallbackResult);
@@ -27,9 +31,33 @@ using GpuFinishedProc = void (*)(GpuFinishedContext finishedContext, CallbackRes
  * the Recording that they may be holding onto. If the Recording is successfully submitted to the
  * GPU the callback will be called with CallbackResult::kSuccess once the GPU has finished. All
  * other cases where some failure occured it will be called with CallbackResult::kFailed.
+ *
+ * The fTargetSurface, if provided, is used as a target for any draws recorded onto a deferred
+ * canvas returned from Recorder::makeDeferredCanvas. This target surface must be provided iff
+ * the Recording contains any such draws. It must be Graphite-backed and its backing texture's
+ * TextureInfo must match the info provided to the Recorder when making the deferred canvas.
+ *
+ * fTargetTranslation is an additional translation applied to draws targeting fTargetSurface.
  */
 struct InsertRecordingInfo {
     Recording* fRecording = nullptr;
+
+    SkSurface* fTargetSurface = nullptr;
+    SkIVector fTargetTranslation = {0, 0};
+
+    GpuFinishedContext fFinishedContext = nullptr;
+    GpuFinishedProc fFinishedProc = nullptr;
+};
+
+/**
+ * The fFinishedProc is called when the Recording has been submitted and finished on the GPU, or
+ * when there is a failure that caused it not to be submitted. The callback will always be called
+ * and the caller can use the callback to know it is safe to free any resources associated with
+ * the Recording that they may be holding onto. If the Recording is successfully submitted to the
+ * GPU the callback will be called with CallbackResult::kSuccess once the GPU has finished. All
+ * other cases where some failure occured it will be called with CallbackResult::kFailed.
+ */
+struct InsertFinishInfo {
     GpuFinishedContext fFinishedContext = nullptr;
     GpuFinishedProc fFinishedProc = nullptr;
 };
@@ -42,12 +70,34 @@ enum class SyncToCpu : bool {
     kNo = false
 };
 
-/**
- * Is the texture mipmapped or not
+/*
+ * For Promise Images - should the Promise Image be fulfilled every time a Recording that references
+ * it is inserted into the Context.
  */
-enum class Mipmapped : bool {
-    kNo = false,
-    kYes = true,
+enum class Volatile : bool {
+    kNo = false,              // only fulfilled once
+    kYes = true               // fulfilled on every insertion call
+};
+
+/*
+ * Graphite's different rendering methods each only apply to certain types of draws. This
+ * enum supports decision-making regarding the different renderers and what is being drawn.
+ */
+enum DrawTypeFlags : uint8_t {
+
+    kNone         = 0b000,
+
+    // SkCanvas:: drawSimpleText, drawString, drawGlyphs, drawTextBlob, drawSlug
+    kText         = 0b001,
+
+    // SkCanvas::drawVertices
+    kDrawVertices = 0b010,
+
+    // All other canvas draw calls
+    kShape        = 0b100,
+
+    kMostCommon = kText | kShape,
+    kAll = kText | kDrawVertices | kShape
 };
 
 } // namespace skgpu::graphite

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

@@ -13,7 +13,6 @@
 
 namespace skgpu::graphite {
 
-enum class Mipmapped : bool;
 class Recorder;
 
 /*
@@ -23,9 +22,12 @@ class Recorder;
  * return a Graphite-backed version of the provided SkImage that meets the specified
  * requirements.
  *
- * Skia requires that 'findOrCreate' return a Graphite-backed image that preserves the dimensions,
- * number of channels and alpha type of the original image. The bit depth of the
- * individual channels can change (e.g., 4444 -> 8888 is allowed).
+ * Skia requires that 'findOrCreate' return a Graphite-backed image that preserves the
+ * dimensions and alpha type of the original image. The bit depth of the
+ * individual channels can change (e.g., 4444 -> 8888 is allowed) as well as the channels - as
+ * long as the returned image has a superset of the original image's channels
+ * (e.g., 565 -> 8888 opaque is allowed).
+ *
  * Wrt mipmapping, the returned image can have different mipmap settings than requested. If
  * mipmapping was requested but not returned, the sampling level will be reduced to linear.
  * If the requirements are not met by the returned image (modulo the flexibility wrt mipmapping)

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

@@ -11,17 +11,20 @@
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSize.h"
 #include "include/gpu/graphite/GraphiteTypes.h"
-#include "include/private/SingleOwner.h"
-#include "include/private/SkTHash.h"
+#include "include/gpu/graphite/Recording.h"
+#include "include/private/base/SingleOwner.h"
+#include "include/private/base/SkTArray.h"
 
 #include <vector>
 
+class SkCanvas;
+struct SkImageInfo;
 class SkPixmap;
-class SkRuntimeEffectDictionary;
-class SkTextureDataBlock;
-class SkUniformDataBlock;
 
-namespace skgpu { class TokenTracker; }
+namespace skgpu {
+class RefCntedCallback;
+class TokenTracker;
+}
 
 namespace sktext::gpu {
 class StrikeCache;
@@ -33,22 +36,26 @@ namespace skgpu::graphite {
 class AtlasManager;
 class BackendTexture;
 class Caps;
+class Context;
 class Device;
 class DrawBufferManager;
 class GlobalCache;
 class ImageProvider;
+class ProxyCache;
 class RecorderPriv;
-class Recording;
 class ResourceProvider;
+class RuntimeEffectDictionary;
 class SharedContext;
 class Task;
 class TaskGraph;
+class TextureDataBlock;
 class TextureInfo;
+class UniformDataBlock;
 class UploadBufferManager;
 
 template<typename T> class PipelineDataCache;
-using UniformDataCache = PipelineDataCache<SkUniformDataBlock>;
-using TextureDataCache = PipelineDataCache<SkTextureDataBlock>;
+using UniformDataCache = PipelineDataCache<UniformDataBlock>;
+using TextureDataCache = PipelineDataCache<TextureDataBlock>;
 
 struct SK_API RecorderOptions final {
     RecorderOptions();
@@ -115,11 +122,23 @@ public:
      */
     void deleteBackendTexture(BackendTexture&);
 
+    // Adds a proc that will be moved to the Recording upon snap, subsequently attached to the
+    // CommandBuffer when the Recording is added, and called when that CommandBuffer is submitted
+    // and finishes. If the Recorder or Recording is deleted before the proc is added to the
+    // CommandBuffer, it will be called with result Failure.
+    void addFinishInfo(const InsertFinishInfo&);
+
+    // Returns a canvas that will record to a proxy surface, which must be instantiated on replay.
+    // This can only be called once per Recording; subsequent calls will return null until a
+    // Recording is snapped. Additionally, the returned SkCanvas is only valid until the next
+    // Recording snap, at which point it is deleted.
+    SkCanvas* makeDeferredCanvas(const SkImageInfo&, const TextureInfo&);
+
     // Provides access to functions that aren't part of the public API.
     RecorderPriv priv();
     const RecorderPriv priv() const;  // NOLINT(readability-const-return-type)
 
-#if GR_TEST_UTILS
+#if GRAPHITE_TEST_UTILS
     bool deviceIsRegistered(Device*);
 #endif
 
@@ -156,7 +175,7 @@ private:
 
     sk_sp<SharedContext> fSharedContext;
     std::unique_ptr<ResourceProvider> fResourceProvider;
-    std::unique_ptr<SkRuntimeEffectDictionary> fRuntimeEffectDict;
+    std::unique_ptr<RuntimeEffectDictionary> fRuntimeEffectDict;
 
     std::unique_ptr<TaskGraph> fGraph;
     std::unique_ptr<UniformDataCache> fUniformDataCache;
@@ -176,6 +195,17 @@ private:
     // This guard is passed to the ResourceCache.
     // TODO: Should we also pass this to Device, DrawContext, and similar classes?
     mutable SingleOwner fSingleOwner;
+
+    sk_sp<Device> fTargetProxyDevice;
+    std::unique_ptr<SkCanvas> fTargetProxyCanvas;
+    std::unique_ptr<Recording::LazyProxyData> fTargetProxyData;
+
+    skia_private::TArray<sk_sp<RefCntedCallback>> fFinishedProcs;
+
+#if GRAPHITE_TEST_UTILS
+    // For testing use only -- the Context used to create this Recorder
+    Context* fContext = nullptr;
+#endif
 };
 
 } // namespace skgpu::graphite

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

@@ -9,10 +9,17 @@
 #define skgpu_graphite_Recording_DEFINED
 
 #include "include/core/SkRefCnt.h"
+#include "include/private/SkChecksum.h"
+#include "include/private/base/SkTArray.h"
 
 #include <memory>
+#include <unordered_set>
 #include <vector>
 
+namespace skgpu {
+class RefCntedCallback;
+}
+
 namespace skgpu::graphite {
 
 class CommandBuffer;
@@ -20,18 +27,51 @@ class RecordingPriv;
 class Resource;
 class ResourceProvider;
 class TaskGraph;
+class Texture;
+class TextureInfo;
+class TextureProxy;
 
-class Recording final {
+class SK_API Recording final {
 public:
     ~Recording();
 
     RecordingPriv priv();
 
+#if GRAPHITE_TEST_UTILS
+    bool isTargetProxyInstantiated() const;
+#endif
+
 private:
-    friend class Recorder; // for ctor
+    friend class Recorder;  // for ctor and LazyProxyData
     friend class RecordingPriv;
 
-    Recording(std::unique_ptr<TaskGraph>);
+    // LazyProxyData is used if this recording should be replayed to a target that is provided on
+    // replay, and it handles the target proxy's instantiation with the provided target.
+    class LazyProxyData {
+    public:
+        LazyProxyData(const TextureInfo&);
+
+        TextureProxy* lazyProxy();
+        sk_sp<TextureProxy> refLazyProxy();
+
+        bool lazyInstantiate(ResourceProvider*, sk_sp<Texture>);
+
+    private:
+        sk_sp<Texture> fTarget;
+        sk_sp<TextureProxy> fTargetProxy;
+    };
+
+    struct ProxyHash {
+        std::size_t operator()(const sk_sp<TextureProxy>& proxy) const {
+            return SkGoodHash()(proxy.get());
+        }
+    };
+
+    Recording(std::unique_ptr<TaskGraph>,
+              std::unordered_set<sk_sp<TextureProxy>, ProxyHash>&& nonVolatileLazyProxies,
+              std::unordered_set<sk_sp<TextureProxy>, ProxyHash>&& volatileLazyProxies,
+              std::unique_ptr<LazyProxyData> targetProxyData,
+              skia_private::TArray<sk_sp<RefCntedCallback>>&& finishedProcs);
 
     bool addCommands(CommandBuffer*, ResourceProvider*);
     void addResourceRef(sk_sp<Resource>);
@@ -42,6 +82,13 @@ private:
     // Those refs are stored in the array here and will eventually be passed onto a CommandBuffer
     // when the Recording adds its commands.
     std::vector<sk_sp<Resource>> fExtraResourceRefs;
+
+    std::unordered_set<sk_sp<TextureProxy>, ProxyHash> fNonVolatileLazyProxies;
+    std::unordered_set<sk_sp<TextureProxy>, ProxyHash> fVolatileLazyProxies;
+
+    std::unique_ptr<LazyProxyData> fTargetProxyData;
+
+    skia_private::TArray<sk_sp<RefCntedCallback>> fFinishedProcs;
 };
 
 } // namespace skgpu::graphite

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

@@ -10,8 +10,12 @@
 
 #include "include/gpu/graphite/GraphiteTypes.h"
 
+#ifdef SK_DAWN
+#include "include/private/gpu/graphite/DawnTypesPriv.h"
+#endif
+
 #ifdef SK_METAL
-#include "include/private/gpu/graphite/MtlTypesPriv.h"
+#include "include/private/gpu/graphite/MtlGraphiteTypesPriv.h"
 #endif
 
 #ifdef SK_VULKAN
@@ -20,15 +24,25 @@
 
 namespace skgpu::graphite {
 
-class TextureInfo {
+class SK_API TextureInfo {
 public:
     TextureInfo() {}
+#ifdef SK_DAWN
+    TextureInfo(const DawnTextureInfo& dawnInfo)
+            : fBackend(BackendApi::kDawn)
+            , fValid(true)
+            , fSampleCount(dawnInfo.fSampleCount)
+            , fMipmapped(dawnInfo.fMipmapped)
+            , fProtected(Protected::kNo)
+            , fDawnSpec(dawnInfo) {}
+#endif
+
 #ifdef SK_METAL
     TextureInfo(const MtlTextureInfo& mtlInfo)
             : fBackend(BackendApi::kMetal)
             , fValid(true)
             , fSampleCount(mtlInfo.fSampleCount)
-            , fLevelCount(mtlInfo.fLevelCount)
+            , fMipmapped(mtlInfo.fMipmapped)
             , fProtected(Protected::kNo)
             , fMtlSpec(mtlInfo) {}
 #endif
@@ -38,7 +52,7 @@ public:
             : fBackend(BackendApi::kVulkan)
             , fValid(true)
             , fSampleCount(vkInfo.fSampleCount)
-            , fLevelCount(vkInfo.fLevelCount)
+            , fMipmapped(vkInfo.fMipmapped)
             , fProtected(Protected::kNo)
             , fVkSpec(vkInfo) {
         if (vkInfo.fFlags & VK_IMAGE_CREATE_PROTECTED_BIT) {
@@ -58,15 +72,25 @@ public:
     BackendApi backend() const { return fBackend; }
 
     uint32_t numSamples() const { return fSampleCount; }
-    uint32_t numMipLevels() const { return fLevelCount; }
+    Mipmapped mipmapped() const { return fMipmapped; }
     Protected isProtected() const { return fProtected; }
 
+#ifdef SK_DAWN
+    bool getDawnTextureInfo(DawnTextureInfo* info) const {
+        if (!this->isValid() || fBackend != BackendApi::kDawn) {
+            return false;
+        }
+        *info = DawnTextureSpecToTextureInfo(fDawnSpec, fSampleCount, fMipmapped);
+        return true;
+    }
+#endif
+
 #ifdef SK_METAL
     bool getMtlTextureInfo(MtlTextureInfo* info) const {
         if (!this->isValid() || fBackend != BackendApi::kMetal) {
             return false;
         }
-        *info = MtlTextureSpecToTextureInfo(fMtlSpec, fSampleCount, fLevelCount);
+        *info = MtlTextureSpecToTextureInfo(fMtlSpec, fSampleCount, fMipmapped);
         return true;
     }
 #endif
@@ -76,12 +100,24 @@ public:
         if (!this->isValid() || fBackend != BackendApi::kVulkan) {
             return false;
         }
-        *info = VulkanTextureSpecToTextureInfo(fVkSpec, fSampleCount, fLevelCount);
+        *info = VulkanTextureSpecToTextureInfo(fVkSpec, fSampleCount, fMipmapped);
         return true;
     }
 #endif
 
 private:
+#ifdef SK_DAWN
+    friend class DawnCaps;
+    friend class DawnCommandBuffer;
+    friend class DawnGraphicsPipeline;
+    friend class DawnResourceProvider;
+    friend class DawnTexture;
+    const DawnTextureSpec& dawnTextureSpec() const {
+        SkASSERT(fValid && fBackend == BackendApi::kDawn);
+        return fDawnSpec;
+    }
+#endif
+
 #ifdef SK_METAL
     friend class MtlCaps;
     friend class MtlGraphicsPipeline;
@@ -105,10 +141,13 @@ private:
     bool fValid = false;
 
     uint32_t fSampleCount = 1;
-    uint32_t fLevelCount = 0;
+    Mipmapped fMipmapped = Mipmapped::kNo;
     Protected fProtected = Protected::kNo;
 
     union {
+#ifdef SK_DAWN
+        DawnTextureSpec fDawnSpec;
+#endif
 #ifdef SK_METAL
         MtlTextureSpec fMtlSpec;
 #endif