@shopify/react-native-skia 0.1.192 → 0.1.194

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

@@ -0,0 +1,139 @@
+/*
+ * Copyright 2023 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_YUVABackendTextures_DEFINED
+#define skgpu_graphite_YUVABackendTextures_DEFINED
+
+#include "include/core/SkSpan.h"
+#include "include/core/SkYUVAInfo.h"
+#include "include/gpu/graphite/BackendTexture.h"
+
+#include <tuple>
+
+namespace skgpu::graphite {
+class Recorder;
+
+/**
+ * A description of a set of BackendTextures that hold the planar data described by a SkYUVAInfo.
+ */
+class SK_API YUVABackendTextureInfo {
+public:
+    static constexpr auto kMaxPlanes = SkYUVAInfo::kMaxPlanes;
+
+    /** Default YUVABackendTextureInfo is invalid. */
+    YUVABackendTextureInfo() = default;
+    YUVABackendTextureInfo(const YUVABackendTextureInfo&) = default;
+    YUVABackendTextureInfo& operator=(const YUVABackendTextureInfo&) = default;
+
+    /**
+     * Initializes a YUVABackendTextureInfo to describe a set of textures that can store the
+     * planes indicated by the SkYUVAInfo. The texture dimensions are taken from the SkYUVAInfo's
+     * plane dimensions. All the described textures share a common origin. The planar image this
+     * describes will be mip mapped if all the textures are individually mip mapped as indicated
+     * 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&,
+                           const TextureInfo[kMaxPlanes],
+                           Mipmapped);
+
+    bool operator==(const YUVABackendTextureInfo&) const;
+    bool operator!=(const YUVABackendTextureInfo& that) const { return !(*this == that); }
+
+    /** TextureInfo for the ith plane, or invalid if i >= numPlanes() */
+    const TextureInfo& planeTextureInfo(int i) const {
+        SkASSERT(i >= 0);
+        return fPlaneTextureInfos[static_cast<size_t>(i)];
+    }
+
+    const SkYUVAInfo& yuvaInfo() const { return fYUVAInfo; }
+
+    SkYUVColorSpace yuvColorSpace() const { return fYUVAInfo.yuvColorSpace(); }
+
+    Mipmapped mipmapped() const { return fMipmapped; }
+
+    /** The number of planes, 0 if this YUVABackendTextureInfo is invalid. */
+    int numPlanes() const { return fYUVAInfo.numPlanes(); }
+
+    /**
+     * Returns true if this has been configured with a valid SkYUVAInfo with compatible texture
+     * formats.
+     */
+    bool isValid() const { return fYUVAInfo.isValid(); }
+
+    /**
+     * Computes a YUVALocations representation of the planar layout. The result is guaranteed to be
+     * valid if this->isValid().
+     */
+    SkYUVAInfo::YUVALocations toYUVALocations() const;
+
+private:
+    SkYUVAInfo fYUVAInfo;
+    std::array<TextureInfo, kMaxPlanes> fPlaneTextureInfos;
+    std::array<uint32_t, kMaxPlanes> fPlaneChannelMasks;
+    Mipmapped fMipmapped = Mipmapped::kNo;
+};
+
+/**
+ * A set of BackendTextures that hold the planar data for an image described a SkYUVAInfo.
+ */
+class SK_API YUVABackendTextures {
+public:
+    static constexpr auto kMaxPlanes = SkYUVAInfo::kMaxPlanes;
+
+    YUVABackendTextures() = default;
+    YUVABackendTextures(const YUVABackendTextures&) = delete;
+    YUVABackendTextures& operator=(const YUVABackendTextures&) = delete;
+
+    /**
+     * Initializes a YUVABackendTextures object from a set of textures that store the planes
+     * 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&,
+                        const BackendTexture[kMaxPlanes]);
+
+    SkSpan<const BackendTexture> planeTextures() const {
+        return SkSpan<const BackendTexture>(fPlaneTextures);
+    }
+
+    /** BackendTexture for the ith plane, or invalid if i >= numPlanes() */
+    BackendTexture planeTexture(int i) const {
+        SkASSERT(i >= 0);
+        return fPlaneTextures[static_cast<size_t>(i)];
+    }
+
+    const SkYUVAInfo& yuvaInfo() const { return fYUVAInfo; }
+
+    SkYUVColorSpace yuvColorSpace() const { return fYUVAInfo.yuvColorSpace(); }
+
+    /** The number of planes, 0 if this YUVABackendTextureInfo is invalid. */
+    int numPlanes() const { return fYUVAInfo.numPlanes(); }
+
+    /**
+     * Returns true if this has been configured with a valid SkYUVAInfo with compatible texture
+     * formats.
+     */
+    bool isValid() const { return fYUVAInfo.isValid(); }
+
+    /**
+     * Computes a YUVALocations representation of the planar layout. The result is guaranteed to be
+     * valid if this->isValid().
+     */
+    SkYUVAInfo::YUVALocations toYUVALocations() const;
+
+private:
+    SkYUVAInfo fYUVAInfo;
+    std::array<BackendTexture, kMaxPlanes> fPlaneTextures;
+    std::array<uint32_t, kMaxPlanes> fPlaneChannelMasks;
+};
+
+}  // End of namespace skgpu::graphite
+
+#endif  // skgpu_graphite_YUVABackendTextures_DEFINED

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

@@ -0,0 +1,40 @@
+/*
+ * 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/gpu/graphite/GraphiteTypes.h"
+#include "webgpu/webgpu_cpp.h"
+
+namespace skgpu::graphite {
+
+struct DawnTextureInfo {
+    uint32_t fSampleCount = 1;
+    Mipmapped fMipmapped = Mipmapped::kNo;
+
+    // wgpu::TextureDescriptor properties
+    wgpu::TextureFormat fFormat = wgpu::TextureFormat::Undefined;
+    wgpu::TextureUsage  fUsage = wgpu::TextureUsage::None;
+
+    DawnTextureInfo() = default;
+    DawnTextureInfo(const wgpu::Texture& texture);
+    DawnTextureInfo(uint32_t sampleCount,
+                    Mipmapped mipmapped,
+                    wgpu::TextureFormat format,
+                    wgpu::TextureUsage usage)
+            : fSampleCount(sampleCount)
+            , fMipmapped(mipmapped)
+            , fFormat(format)
+            , fUsage(usage) {}
+};
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_DawnTypes_DEFINED
+
+

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

@@ -0,0 +1,28 @@
+/*
+ * 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_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

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

@@ -8,7 +8,7 @@
 #ifndef skgpu_graphite_MtlBackendContext_DEFINED
 #define skgpu_graphite_MtlBackendContext_DEFINED
 
-#include "include/gpu/graphite/mtl/MtlTypes.h"
+#include "include/gpu/graphite/mtl/MtlGraphiteTypes.h"
 
 namespace skgpu::graphite {
 

package/cpp/skia/include/gpu/graphite/mtl/{MtlTypes.h → MtlGraphiteTypes.h}

@@ -5,9 +5,10 @@
  * found in the LICENSE file.
  */
 
-#ifndef skgpu_graphite_MtlTypes_DEFINED
-#define skgpu_graphite_MtlTypes_DEFINED
+#ifndef skgpu_graphite_MtlGraphiteTypes_DEFINED
+#define skgpu_graphite_MtlGraphiteTypes_DEFINED
 
+#include "include/gpu/graphite/GraphiteTypes.h"
 #include "include/ports/SkCFObject.h"
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -38,7 +39,7 @@ using MtlHandle = const void*;
 
 struct MtlTextureInfo {
     uint32_t fSampleCount = 1;
-    uint32_t fLevelCount = 0;
+    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.
@@ -50,13 +51,13 @@ struct MtlTextureInfo {
     MtlTextureInfo() = default;
     MtlTextureInfo(MtlHandle mtlTexture);
     MtlTextureInfo(uint32_t sampleCount,
-                   uint32_t levelCount,
+                   skgpu::Mipmapped mipmapped,
                    MtlPixelFormat format,
                    MtlTextureUsage usage,
                    MtlStorageMode storageMode,
                    bool framebufferOnly)
             : fSampleCount(sampleCount)
-            , fLevelCount(levelCount)
+            , fMipmapped(mipmapped)
             , fFormat(format)
             , fUsage(usage)
             , fStorageMode(storageMode)
@@ -65,4 +66,4 @@ struct MtlTextureInfo {
 
 } // namespace skgpu::graphite
 
-#endif // skgpu_graphite_MtlTypes_DEFINED
+#endif // skgpu_graphite_MtlGraphiteTypes_DEFINED

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

@@ -0,0 +1,27 @@
+/*
+ * 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_MtlGraphiteUtils_DEFINED
+#define skgpu_graphite_MtlGraphiteUtils_DEFINED
+
+#include <memory>
+
+#include "include/private/base/SkAPI.h"
+
+namespace skgpu::graphite {
+
+class Context;
+struct ContextOptions;
+struct MtlBackendContext;
+
+namespace ContextFactory {
+SK_API std::unique_ptr<Context> MakeMetal(const MtlBackendContext&, const ContextOptions&);
+} // namespace ContextFactory
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_MtlGraphiteUtils_DEFINED

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

@@ -8,13 +8,14 @@
 #ifndef skgpu_graphite_VulkanGraphiteTypes_DEFINED
 #define skgpu_graphite_VulkanGraphiteTypes_DEFINED
 
+#include "include/gpu/graphite/GraphiteTypes.h"
 #include "include/gpu/vk/VulkanTypes.h"
 
 namespace skgpu::graphite {
 
 struct VulkanTextureInfo {
     uint32_t fSampleCount = 1;
-    uint32_t fLevelCount = 0;
+    Mipmapped fMipmapped = Mipmapped::kNo;
 
     // VkImageCreateInfo properties
     // Currently the only supported flag is VK_IMAGE_CREATE_PROTECTED_BIT. Any other flag will not
@@ -24,8 +25,6 @@ struct VulkanTextureInfo {
     VkImageTiling            fImageTiling = VK_IMAGE_TILING_OPTIMAL;
     VkImageUsageFlags        fImageUsageFlags = 0;
     VkSharingMode            fSharingMode = VK_SHARING_MODE_EXCLUSIVE;
-    uint32_t                 fCurrentQueueFamily = VK_QUEUE_FAMILY_IGNORED;
-    VkImageLayout            fImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 
     // Properties related to the image view and sampling. These are less inherent properties of the
     // VkImage but describe how the VkImage should be used within Skia.
@@ -41,24 +40,20 @@ struct VulkanTextureInfo {
 
     VulkanTextureInfo() = default;
     VulkanTextureInfo(uint32_t sampleCount,
-                      uint32_t levelCount,
+                      Mipmapped mipmapped,
                       VkImageCreateFlags flags,
                       VkFormat format,
                       VkImageTiling imageTiling,
                       VkImageUsageFlags imageUsageFlags,
                       VkSharingMode sharingMode,
-                      uint32_t currentQueueFamily,
-                      VkImageLayout imageLayout,
                       VkImageAspectFlags aspectMask)
             : fSampleCount(sampleCount)
-            , fLevelCount(levelCount)
+            , fMipmapped(mipmapped)
             , fFlags(flags)
             , fFormat(format)
             , fImageTiling(imageTiling)
             , fImageUsageFlags(imageUsageFlags)
             , fSharingMode(sharingMode)
-            , fCurrentQueueFamily(currentQueueFamily)
-            , fImageLayout(imageLayout)
             , fAspectMask(aspectMask) {}
 };
 

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

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_VulkanGraphiteUtils_DEFINED
+#define skgpu_graphite_VulkanGraphiteUtils_DEFINED
+
+#include <memory>
+
+#include "include/private/base/SkAPI.h"
+
+namespace skgpu { struct VulkanBackendContext; }
+
+namespace skgpu::graphite {
+
+class Context;
+struct ContextOptions;
+
+namespace ContextFactory {
+SK_API std::unique_ptr<Context> MakeVulkan(const VulkanBackendContext&, const ContextOptions&);
+} // namespace ContextFactory
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_VulkanGraphiteUtils_DEFINED

package/cpp/skia/include/gpu/mock/GrMockTypes.h

@@ -8,7 +8,8 @@
 #ifndef GrMockOptions_DEFINED
 #define GrMockOptions_DEFINED
 
-#include "include/gpu/GrTypes.h"
+#include "include/core/SkTextureCompressionType.h"
+#include "include/gpu/GpuTypes.h"
 #include "include/private/gpu/ganesh/GrTypesPriv.h"
 
 class GrBackendFormat;
@@ -16,17 +17,17 @@ class GrBackendFormat;
 struct GrMockTextureInfo {
     GrMockTextureInfo()
         : fColorType(GrColorType::kUnknown)
-        , fCompressionType(SkImage::CompressionType::kNone)
+        , fCompressionType(SkTextureCompressionType::kNone)
         , fID(0) {}
 
     GrMockTextureInfo(GrColorType colorType,
-                      SkImage::CompressionType compressionType,
+                      SkTextureCompressionType compressionType,
                       int id)
             : fColorType(colorType)
             , fCompressionType(compressionType)
             , fID(id) {
         SkASSERT(fID);
-        if (fCompressionType != SkImage::CompressionType::kNone) {
+        if (fCompressionType != SkTextureCompressionType::kNone) {
             SkASSERT(colorType == GrColorType::kUnknown);
         }
     }
@@ -39,10 +40,10 @@ struct GrMockTextureInfo {
 
     GrBackendFormat getBackendFormat() const;
 
-    SkImage::CompressionType compressionType() const { return fCompressionType; }
+    SkTextureCompressionType compressionType() const { return fCompressionType; }
 
     GrColorType colorType() const {
-        SkASSERT(fCompressionType == SkImage::CompressionType::kNone);
+        SkASSERT(fCompressionType == SkTextureCompressionType::kNone);
         return fColorType;
     }
 
@@ -50,7 +51,7 @@ struct GrMockTextureInfo {
 
 private:
     GrColorType              fColorType;
-    SkImage::CompressionType fCompressionType;
+    SkTextureCompressionType fCompressionType;
     int                      fID;
 };
 
@@ -82,12 +83,15 @@ private:
 struct GrMockSurfaceInfo {
     uint32_t fSampleCount = 1;
     uint32_t fLevelCount = 0;
-    GrProtected fProtected = GrProtected::kNo;
+    skgpu::Protected fProtected = skgpu::Protected::kNo;
 
     GrColorType fColorType = GrColorType::kUnknown;
-    SkImage::CompressionType fCompressionType = SkImage::CompressionType::kNone;
+    SkTextureCompressionType fCompressionType = SkTextureCompressionType::kNone;
 };
 
+static constexpr int kSkTextureCompressionTypeCount =
+        static_cast<int>(SkTextureCompressionType::kLast) + 1;
+
 /**
  * A pointer to this type is used as the GrBackendContext when creating a Mock GrContext. It can be
  * used to specify capability options for the mock context. If nullptr is used a default constructed
@@ -105,9 +109,9 @@ struct GrMockOptions {
 
         fConfigOptions[(int)GrColorType::kBGRA_8888] = fConfigOptions[(int)GrColorType::kRGBA_8888];
 
-        fCompressedOptions[(int)SkImage::CompressionType::kETC2_RGB8_UNORM].fTexturable = true;
-        fCompressedOptions[(int)SkImage::CompressionType::kBC1_RGB8_UNORM].fTexturable = true;
-        fCompressedOptions[(int)SkImage::CompressionType::kBC1_RGBA8_UNORM].fTexturable = true;
+        fCompressedOptions[(int)SkTextureCompressionType::kETC2_RGB8_UNORM].fTexturable = true;
+        fCompressedOptions[(int)SkTextureCompressionType::kBC1_RGB8_UNORM].fTexturable = true;
+        fCompressedOptions[(int)SkTextureCompressionType::kBC1_RGBA8_UNORM].fTexturable = true;
     }
 
     struct ConfigOptions {
@@ -126,7 +130,7 @@ struct GrMockOptions {
     int fMaxWindowRectangles = 0;
     int fMaxVertexAttributes = 16;
     ConfigOptions fConfigOptions[kGrColorTypeCnt];
-    ConfigOptions fCompressedOptions[SkImage::kCompressionTypeCount];
+    ConfigOptions fCompressedOptions[kSkTextureCompressionTypeCount];
 
     // GrShaderCaps options.
     bool fIntegerSupport = false;

package/cpp/skia/include/gpu/mtl/GrMtlTypes.h

@@ -8,7 +8,7 @@
 #ifndef GrMtlTypes_DEFINED
 #define GrMtlTypes_DEFINED
 
-#include "include/gpu/GrTypes.h"
+#include "include/gpu/GpuTypes.h"
 #include "include/ports/SkCFObject.h"
 
 /**
@@ -49,7 +49,7 @@ public:
 struct GrMtlSurfaceInfo {
     uint32_t fSampleCount = 1;
     uint32_t fLevelCount = 0;
-    GrProtected fProtected = GrProtected::kNo;
+    skgpu::Protected fProtected = skgpu::Protected::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.

package/cpp/skia/include/gpu/vk/GrVkBackendContext.h

@@ -72,7 +72,7 @@ struct SK_API GrVkBackendContext {
     bool                                fOwnsInstanceAndDevice = false;
     // Indicates that we are working with protected content and all CommandPool and Queue operations
     // should be done in a protected context.
-    GrProtected                         fProtectedContext = GrProtected::kNo;
+    skgpu::Protected                    fProtectedContext = skgpu::Protected::kNo;
 };
 
 #endif

package/cpp/skia/include/gpu/vk/GrVkTypes.h

@@ -9,7 +9,7 @@
 #ifndef GrVkTypes_DEFINED
 #define GrVkTypes_DEFINED
 
-#include "include/gpu/GrTypes.h"
+#include "include/gpu/GpuTypes.h"
 #include "include/gpu/vk/VulkanTypes.h"
 
 using GrVkBackendMemory = skgpu::VulkanBackendMemory;
@@ -72,7 +72,7 @@ struct GrVkImageInfo {
     uint32_t                 fSampleCount = 1;
     uint32_t                 fLevelCount = 0;
     uint32_t                 fCurrentQueueFamily = VK_QUEUE_FAMILY_IGNORED;
-    GrProtected              fProtected = GrProtected::kNo;
+    skgpu::Protected         fProtected = skgpu::Protected::kNo;
     GrVkYcbcrConversionInfo  fYcbcrConversionInfo;
     VkSharingMode            fSharingMode = VK_SHARING_MODE_EXCLUSIVE;
 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
@@ -137,7 +137,7 @@ struct GrVkDrawableInfo {
 struct GrVkSurfaceInfo {
     uint32_t fSampleCount = 1;
     uint32_t fLevelCount = 0;
-    GrProtected fProtected = GrProtected::kNo;
+    skgpu::Protected fProtected = skgpu::Protected::kNo;
 
     VkImageTiling fImageTiling = VK_IMAGE_TILING_OPTIMAL;
     VkFormat fFormat = VK_FORMAT_UNDEFINED;

package/cpp/skia/include/gpu/vk/VulkanExtensions.h

@@ -10,7 +10,7 @@
 
 #include "include/core/SkString.h"
 #include "include/gpu/vk/VulkanTypes.h"
-#include "include/private/SkTArray.h"
+#include "include/private/base/SkTArray.h"
 
 namespace skgpu {
 
@@ -48,7 +48,7 @@ public:
 #ifdef SK_DEBUG
     void dump() const {
         SkDebugf("**Vulkan Extensions**\n");
-        for (int i = 0; i < fExtensions.count(); ++i) {
+        for (int i = 0; i < fExtensions.size(); ++i) {
             SkDebugf("%s. Version: %d\n",
                      fExtensions[i].fName.c_str(), fExtensions[i].fSpecVersion);
         }
@@ -59,7 +59,7 @@ public:
 private:
     void getSpecVersions(VulkanGetProc getProc, VkInstance, VkPhysicalDevice);
 
-    SkTArray<Info> fExtensions;
+    skia_private::TArray<Info> fExtensions;
 };
 
 } // namespace skgpu

package/cpp/skia/include/gpu/vk/VulkanMemoryAllocator.h

@@ -35,7 +35,7 @@ public:
     };
 
     enum class BufferUsage {
-        // Buffers that will only be accessed from the device (large const buffers). Will always be
+        // Buffers that will only be accessed from the device (large const buffers) will always be
         // in device local memory.
         kGpuOnly,
         // Buffers that typically will be updated multiple times by the host and read on the gpu
@@ -103,12 +103,10 @@ public:
 
     virtual void freeMemory(const skgpu::VulkanBackendMemory&) = 0;
 
-    // Returns the total amount of memory that is allocated and in use by an allocation for this
-    // allocator.
-    virtual uint64_t totalUsedMemory() const = 0;
-
-    // Returns the total amount of memory that is allocated by this allocator.
-    virtual uint64_t totalAllocatedMemory() const = 0;
+    // Returns the total amount of memory that is allocated as well as total
+    // amount of memory in use by an allocation from this allocator.
+    // Return 1st param is total allocated memory, 2nd is total used memory.
+    virtual std::pair<uint64_t, uint64_t> totalAllocatedAndUsedMemory() const = 0;
 };
 
 } // namespace skgpu

package/cpp/skia/include/pathops/SkPathOps.h

@@ -9,8 +9,8 @@
 
 #include "include/core/SkPath.h"
 #include "include/core/SkTypes.h"
-#include "include/private/SkTArray.h"
-#include "include/private/SkTDArray.h"
+#include "include/private/base/SkTArray.h"
+#include "include/private/base/SkTDArray.h"
 
 struct SkRect;
 
@@ -102,7 +102,7 @@ public:
     bool resolve(SkPath* result);
 
 private:
-    SkTArray<SkPath> fPathRefs;
+    skia_private::TArray<SkPath> fPathRefs;
     SkTDArray<SkPathOp> fOps;
 
     static bool FixWinding(SkPath* path);

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

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2023 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkFontMgr_data_DEFINED
+#define SkFontMgr_data_DEFINED
+
+#include "include/core/SkData.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSpan.h"
+#include "include/core/SkTypes.h"
+
+class SkFontMgr;
+
+/** Create a custom font manager which wraps a collection of SkData-stored fonts.
+ *  This font manager uses FreeType for rendering.
+ */
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_Custom_Data(SkSpan<sk_sp<SkData>>);
+
+#endif // SkFontMgr_data_DEFINED