@shopify/react-native-skia 1.3.12 → 1.4.0

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

@@ -16,7 +16,6 @@
 #include "include/private/base/SkTArray.h"
 
 #include <chrono>
-#include <vector>
 
 struct AHardwareBuffer;
 class SkCanvas;
@@ -45,16 +44,18 @@ class DrawBufferManager;
 class GlobalCache;
 class ImageProvider;
 class ProxyCache;
+class ProxyReadCountMap;
 class RecorderPriv;
 class ResourceProvider;
 class RuntimeEffectDictionary;
 class SharedContext;
 class Task;
-class TaskGraph;
+class TaskList;
 class TextureDataBlock;
 class TextureInfo;
 class UniformDataBlock;
 class UploadBufferManager;
+class UploadList;
 
 template<typename T> class PipelineDataCache;
 using UniformDataCache = PipelineDataCache<UniformDataBlock>;
@@ -88,6 +89,11 @@ public:
     ImageProvider* clientImageProvider() { return fClientImageProvider.get(); }
     const ImageProvider* clientImageProvider() const { return fClientImageProvider.get(); }
 
+    /**
+     * Gets the maximum supported texture size.
+     */
+    int maxTextureSize() const;
+
     /**
      * Creates a new backend gpu texture matching the dimensions and TextureInfo. If an invalid
      * TextureInfo or a TextureInfo Skia can't support is passed in, this will return an invalid
@@ -115,7 +121,9 @@ public:
      * to insert a Recording into the Context and call `submit` to send the upload work to the gpu.
      * The backend texture must be compatible with the provided pixmap(s). Compatible, in this case,
      * means that the backend format is compatible with the base pixmap's colortype. The src data
-     * can be deleted when this call returns.
+     * can be deleted when this call returns. When the BackendTexture is safe to be destroyed by the
+     * client, Skia will call the passed in GpuFinishedProc. The BackendTexture should not be
+     * destroyed before that.
      * If the backend texture is mip mapped, the data for all the mipmap levels must be provided.
      * In the mipmapped case all the colortypes of the provided pixmaps must be the same.
      * Additionally, all the miplevels must be sized correctly (please see
@@ -126,7 +134,27 @@ public:
      */
     bool updateBackendTexture(const BackendTexture&,
                               const SkPixmap srcData[],
-                              int numLevels);
+                              int numLevels,
+                              GpuFinishedProc = nullptr,
+                              GpuFinishedContext = nullptr);
+
+    /**
+     * If possible, updates a compressed backend texture filled with the provided raw data. The
+     * client should check the return value to see if the update was successful. The client is
+     * required to insert a Recording into the Context and call `submit` to send the upload work to
+     * the gpu. When the BackendTexture is safe to be destroyed by the client, Skia will call the
+     * passed in GpuFinishedProc. The BackendTexture should not be destroyed before that.
+     * If the backend texture is mip mapped, the data for all the mipmap levels must be provided.
+     * Additionally, all the miplevels must be sized correctly (please see
+     * SkMipMap::ComputeLevelSize and ComputeLevelCount).
+     * For the Vulkan backend after a successful update the layout of the created VkImage will be:
+     *      VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+     */
+    bool updateCompressedBackendTexture(const BackendTexture&,
+                                        const void* data,
+                                        size_t dataSize,
+                                        GpuFinishedProc = nullptr,
+                                        GpuFinishedContext = nullptr);
 
     /**
      * Called to delete the passed in BackendTexture. This should only be called if the
@@ -167,10 +195,21 @@ public:
     void performDeferredCleanup(std::chrono::milliseconds msNotUsed);
 
     /**
-     * Returns the number of bytes of gpu memory currently budgeted in the Recorder's cache.
+     * Returns the number of bytes of the Recorder's gpu memory cache budget that are currently in
+     * use.
      */
     size_t currentBudgetedBytes() const;
 
+    /**
+     * Returns the number of bytes of the Recorder's resource cache that are currently purgeable.
+     */
+    size_t currentPurgeableBytes() const;
+
+    /**
+     * Returns the size of Recorder's gpu memory cache budget in bytes.
+     */
+    size_t maxBudgetedBytes() const;
+
     /**
      * Enumerates all cached GPU resources owned by the Recorder and dumps their memory to
      * traceMemoryDump.
@@ -186,7 +225,9 @@ private:
     friend class Device; // For registering and deregistering Devices;
     friend class RecorderPriv; // for ctor and hidden methods
 
-    Recorder(sk_sp<SharedContext>, const RecorderOptions&);
+    // If Context is non-null, the Recorder will use the Context's resource provider
+    // instead of creating its own.
+    Recorder(sk_sp<SharedContext>, const RecorderOptions&, const Context*);
 
     SingleOwner* singleOwner() const { return &fSingleOwner; }
 
@@ -196,9 +237,10 @@ private:
     // SkSurface/Device first we will flush all the Device's into the Recorder before deregistering
     // it from the Recorder.
     //
-    // We do not need to take a ref on the Device since the Device will flush and deregister itself
-    // in its dtor. There is no other need for the Recorder to know about the Device after this
-    // point.
+    // We take a ref on the Device so that ~Device() does not have to deregister the recorder
+    // (which can happen on any thread if the Device outlives the Surface via an Image view).
+    // Recorder::flushTrackedDevices() cleans up uniquely held and immutable Devices on the recorder
+    // thread so this extra ref is not significantly increasing the Device lifetime.
     //
     // Note: We could probably get by with only registering Devices directly connected to
     // SkSurfaces. All other one off Devices will be created in a controlled scope where the
@@ -207,19 +249,31 @@ private:
     // then either deletes the SkSurface or Recorder before calling restore. For simplicity we just
     // register every device for now, but if we see extra overhead in pushing back the extra
     // pointers, we can look into only registering SkSurface Devices.
-    void registerDevice(Device*);
+    void registerDevice(sk_sp<Device>);
     void deregisterDevice(const Device*);
 
     sk_sp<SharedContext> fSharedContext;
-    std::unique_ptr<ResourceProvider> fResourceProvider;
+    ResourceProvider* fResourceProvider; // May point to the Context's resource provider
+    std::unique_ptr<ResourceProvider> fOwnedResourceProvider; // May be null
     std::unique_ptr<RuntimeEffectDictionary> fRuntimeEffectDict;
 
-    std::unique_ptr<TaskGraph> fGraph;
+    // NOTE: These are stored by pointer to allow them to be forward declared.
+    std::unique_ptr<TaskList> fRootTaskList;
+    // Aggregated one-time uploads that preceed all tasks in the root task list.
+    std::unique_ptr<UploadList> fRootUploads;
+
     std::unique_ptr<UniformDataCache> fUniformDataCache;
     std::unique_ptr<TextureDataCache> fTextureDataCache;
     std::unique_ptr<DrawBufferManager> fDrawBufferManager;
     std::unique_ptr<UploadBufferManager> fUploadBufferManager;
-    std::vector<Device*> fTrackedDevices;
+    std::unique_ptr<ProxyReadCountMap> fProxyReadCounts;
+
+    // Iterating over tracked devices in flushTrackedDevices() needs to be re-entrant and support
+    // additions to fTrackedDevices if registerDevice() is triggered by a temporary device during
+    // flushing. Removals are handled by setting elements to null; final clean up is handled at the
+    // end of the initial call to flushTrackedDevices().
+    skia_private::TArray<sk_sp<Device>> fTrackedDevices;
+    int fFlushingDevicesIndex = -1;
 
     uint32_t fUniqueID;  // Needed for MessageBox handling for text
     uint32_t fNextRecordingID = 1;
@@ -240,7 +294,7 @@ private:
 
     skia_private::TArray<sk_sp<RefCntedCallback>> fFinishedProcs;
 
-#if defined(GRAPHITE_TEST_UTILS)
+#if defined(GPU_TEST_UTILS)
     // For testing use only -- the Context used to create this Recorder
     Context* fContext = nullptr;
 #endif

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

@@ -25,7 +25,7 @@ class CommandBuffer;
 class RecordingPriv;
 class Resource;
 class ResourceProvider;
-class TaskGraph;
+class TaskList;
 class Texture;
 class TextureInfo;
 class TextureProxy;
@@ -62,7 +62,6 @@ private:
 
     Recording(uint32_t uniqueID,
               uint32_t recorderID,
-              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,
@@ -75,7 +74,8 @@ private:
     uint32_t fUniqueID;
     uint32_t fRecorderID;
 
-    std::unique_ptr<TaskGraph> fGraph;
+    // This is held by a pointer instead of being inline to allow TaskList to be forward declared.
+    std::unique_ptr<TaskList> fRootTaskList;
     // We don't always take refs to all resources used by specific Tasks (e.g. a common buffer used
     // for uploads). Instead we'll just hold onto one ref for those Resources outside the Tasks.
     // Those refs are stored in the array here and will eventually be passed onto a CommandBuffer

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

@@ -12,6 +12,8 @@
 #include "include/core/SkSurface.h"
 #include "include/gpu/GpuTypes.h"
 
+#include <string_view>
+
 class SkImage;
 struct SkImageInfo;
 
@@ -59,7 +61,8 @@ SK_API sk_sp<SkImage> AsImageCopy(sk_sp<const SkSurface>,
 SK_API sk_sp<SkSurface> RenderTarget(skgpu::graphite::Recorder*,
                                      const SkImageInfo& imageInfo,
                                      skgpu::Mipmapped = skgpu::Mipmapped::kNo,
-                                     const SkSurfaceProps* surfaceProps = nullptr);
+                                     const SkSurfaceProps* surfaceProps = nullptr,
+                                     std::string_view label = {});
 
 /**
  * Wraps a GPU-backed texture in an SkSurface. Depending on the backend gpu API, the caller may
@@ -80,7 +83,8 @@ SK_API sk_sp<SkSurface> WrapBackendTexture(skgpu::graphite::Recorder*,
                                            sk_sp<SkColorSpace> colorSpace,
                                            const SkSurfaceProps* props,
                                            TextureReleaseProc = nullptr,
-                                           ReleaseContext = nullptr);
+                                           ReleaseContext = nullptr,
+                                           std::string_view label = {});
 }  // namespace SkSurfaces
 
 #endif  // skgpu_graphite_Surface_DEFINED

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

@@ -9,63 +9,22 @@
 #define skgpu_graphite_TextureInfo_DEFINED
 
 #include "include/core/SkString.h"
+#include "include/core/SkTextureCompressionType.h"
 #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/MtlGraphiteTypesPriv.h"
-#endif
-
-#ifdef SK_VULKAN
-#include "include/private/gpu/graphite/VulkanGraphiteTypesPriv.h"
-#endif
+#include "include/private/base/SkAPI.h"
+#include "include/private/base/SkAnySubclass.h"
 
 struct SkISize;
 
 namespace skgpu::graphite {
 
+class TextureInfoData;
+
 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)
-            , fMipmapped(mtlInfo.fMipmapped)
-            , fProtected(Protected::kNo)
-            , fMtlSpec(mtlInfo) {}
-#endif
-
-#ifdef SK_VULKAN
-    TextureInfo(const VulkanTextureInfo& vkInfo)
-            : fBackend(BackendApi::kVulkan)
-            , fValid(true)
-            , fSampleCount(vkInfo.fSampleCount)
-            , fMipmapped(vkInfo.fMipmapped)
-            , fProtected(Protected::kNo)
-            , fVkSpec(vkInfo) {
-        if (vkInfo.fFlags & VK_IMAGE_CREATE_PROTECTED_BIT) {
-            fProtected = Protected::kYes;
-        }
-    }
-#endif
-
-    ~TextureInfo() {}
-    TextureInfo(const TextureInfo&) = default;
+    TextureInfo();
+    ~TextureInfo();
+    TextureInfo(const TextureInfo&);
     TextureInfo& operator=(const TextureInfo&);
 
     bool operator==(const TextureInfo&) const;
@@ -77,71 +36,42 @@ public:
     uint32_t numSamples() const { return fSampleCount; }
     Mipmapped mipmapped() const { return fMipmapped; }
     Protected isProtected() const { return fProtected; }
-
-#ifdef SK_DAWN
-    bool getDawnTextureInfo(DawnTextureInfo* info) const;
-#endif
-
-#ifdef SK_METAL
-    bool getMtlTextureInfo(MtlTextureInfo* info) const {
-        if (!this->isValid() || fBackend != BackendApi::kMetal) {
-            return false;
-        }
-        *info = MtlTextureSpecToTextureInfo(fMtlSpec, fSampleCount, fMipmapped);
-        return true;
-    }
-#endif
-
-#ifdef SK_VULKAN
-    bool getVulkanTextureInfo(VulkanTextureInfo* info) const {
-        if (!this->isValid() || fBackend != BackendApi::kVulkan) {
-            return false;
-        }
-        *info = VulkanTextureSpecToTextureInfo(fVkSpec, fSampleCount, fMipmapped);
-        return true;
-    }
-#endif
+    SkTextureCompressionType compressionType() const;
+    bool isMemoryless() const;
 
     bool isCompatible(const TextureInfo& that) const;
+    // 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);
+    }
+
     friend size_t ComputeSize(SkISize dimensions, const TextureInfo&);  // for bytesPerPixel
 
     size_t bytesPerPixel() const;
 
-#ifdef SK_DAWN
-    friend class DawnCaps;
-    friend class DawnCommandBuffer;
-    friend class DawnComputePipeline;
-    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;
-    friend class MtlTexture;
-    const MtlTextureSpec& mtlTextureSpec() const {
-        SkASSERT(fValid && fBackend == BackendApi::kMetal);
-        return fMtlSpec;
-    }
-#endif
-
-#ifdef SK_VULKAN
-    friend class VulkanCaps;
-    friend class VulkanTexture;
-    const VulkanTextureSpec& vulkanTextureSpec() const {
-        SkASSERT(fValid && fBackend == BackendApi::kVulkan);
-        return fVkSpec;
-    }
-#endif
-
     BackendApi fBackend = BackendApi::kMock;
     bool fValid = false;
 
@@ -149,18 +79,7 @@ private:
     Mipmapped fMipmapped = Mipmapped::kNo;
     Protected fProtected = Protected::kNo;
 
-    union {
-#ifdef SK_DAWN
-        DawnTextureSpec fDawnSpec;
-#endif
-#ifdef SK_METAL
-        MtlTextureSpec fMtlSpec;
-#endif
-#ifdef SK_VULKAN
-        VulkanTextureSpec fVkSpec;
-#endif
-        void* fEnsureUnionNonEmpty;
-    };
+    AnyTextureInfoData fTextureInfoData;
 };
 
 }  // namespace skgpu::graphite

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

@@ -8,37 +8,139 @@
 #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
-    // `fFormat` for multiplanar formats corresponds to the plane TextureView's format.
     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(const wgpu::Texture& texture);
+
     DawnTextureInfo(uint32_t sampleCount,
                     Mipmapped mipmapped,
-                    wgpu::TextureFormat viewFormat,
+                    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(viewFormat)
+            , fFormat(format)
+            , fViewFormat(viewFormat)
             , fUsage(usage)
-            , fAspect(aspect) {}
+            , fAspect(aspect)
+            , fSlice(slice)
+            , fYcbcrVkDescriptor(ycbcrVkDescriptor) {}
+#endif
 };
 
-} // namespace skgpu::graphite
+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/mtl/MtlBackendContext.h

@@ -8,7 +8,10 @@
 #ifndef skgpu_graphite_MtlBackendContext_DEFINED
 #define skgpu_graphite_MtlBackendContext_DEFINED
 
-#include "include/gpu/graphite/mtl/MtlGraphiteTypes.h"
+#include "include/ports/SkCFObject.h"
+#include "include/private/base/SkAPI.h"
+
+#import <CoreFoundation/CoreFoundation.h>
 
 namespace skgpu::graphite {
 

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

@@ -8,15 +8,18 @@
 #ifndef skgpu_graphite_MtlGraphiteTypes_DEFINED
 #define skgpu_graphite_MtlGraphiteTypes_DEFINED
 
+#include "include/core/SkTypes.h"
+
+#if __OBJC__  // <Metal/Metal.h> only works when compiled for Objective C
+#include "include/gpu/graphite/BackendTexture.h"
 #include "include/gpu/graphite/GraphiteTypes.h"
+#include "include/gpu/graphite/TextureInfo.h"
 #include "include/ports/SkCFObject.h"
+#include "include/private/base/SkAPI.h"
 
-///////////////////////////////////////////////////////////////////////////////
-
-#ifdef __APPLE__
-
-#include <CoreFoundation/CoreFoundation.h>
-#include <TargetConditionals.h>
+#import <CoreFoundation/CoreFoundation.h>
+#import <Metal/Metal.h>
+#import <TargetConditionals.h>
 
 #if TARGET_OS_SIMULATOR
 #define SK_API_AVAILABLE_CA_METAL_LAYER SK_API_AVAILABLE(macos(10.11), ios(13.0), tvos(13.0))
@@ -24,36 +27,24 @@
 #define SK_API_AVAILABLE_CA_METAL_LAYER SK_API_AVAILABLE(macos(10.11), ios(8.0), tvos(9.0))
 #endif  // TARGET_OS_SIMULATOR
 
-#endif // __APPLE__
-
-
 namespace skgpu::graphite {
 
-/**
- * Declares typedefs for Metal types used in Graphite cpp code
- */
-using MtlPixelFormat = unsigned int;
-using MtlTextureUsage = unsigned int;
-using MtlStorageMode = unsigned int;
-
-struct MtlTextureInfo {
+struct SK_API MtlTextureInfo {
     uint32_t fSampleCount = 1;
     skgpu::Mipmapped fMipmapped = skgpu::Mipmapped::kNo;
 
-    // Since we aren't in an Obj-C header we can't directly use Mtl types here. Each of these can
-    // cast to their mapped Mtl types list below.
-    MtlPixelFormat fFormat = 0;       // MTLPixelFormat fFormat = MTLPixelFormatInvalid;
-    MtlTextureUsage fUsage = 0;       // MTLTextureUsage fUsage = MTLTextureUsageUnknown;
-    MtlStorageMode fStorageMode = 0;  // MTLStorageMode fStorageMode = MTLStorageModeShared;
+    MTLPixelFormat fFormat = MTLPixelFormatInvalid;
+    MTLTextureUsage fUsage = MTLTextureUsageUnknown;
+    MTLStorageMode fStorageMode = MTLStorageModeShared;
     bool fFramebufferOnly = false;
 
     MtlTextureInfo() = default;
     MtlTextureInfo(CFTypeRef mtlTexture);
     MtlTextureInfo(uint32_t sampleCount,
                    skgpu::Mipmapped mipmapped,
-                   MtlPixelFormat format,
-                   MtlTextureUsage usage,
-                   MtlStorageMode storageMode,
+                   MTLPixelFormat format,
+                   MTLTextureUsage usage,
+                   MTLStorageMode storageMode,
                    bool framebufferOnly)
             : fSampleCount(sampleCount)
             , fMipmapped(mipmapped)
@@ -63,6 +54,31 @@ struct MtlTextureInfo {
             , fFramebufferOnly(framebufferOnly) {}
 };
 
+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  // __OBJC__
+
 #endif // skgpu_graphite_MtlGraphiteTypes_DEFINED