@shopify/react-native-skia 0.1.192 → 0.1.194

package/cpp/skia/include/private/chromium/GrVkSecondaryCBDrawContext.h

@@ -0,0 +1,130 @@
+/*
+ * Copyright 2019 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrVkSecondaryCBDrawContext_DEFINED
+#define GrVkSecondaryCBDrawContext_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSurfaceProps.h"
+#include "include/core/SkTypes.h"
+
+#include <memory>
+
+class GrBackendSemaphore;
+class GrRecordingContext;
+struct GrVkDrawableInfo;
+namespace skgpu::ganesh {
+class Device;
+}
+class SkCanvas;
+class SkDeferredDisplayList;
+struct SkImageInfo;
+class SkSurfaceCharacterization;
+class SkSurfaceProps;
+
+/**
+ * This class is a private header that is intended to only be used inside of Chromium. This requires
+ * Chromium to burrow in and include this specifically since it is not part of skia's public include
+ * directory.
+ */
+
+/**
+ * This class is used to draw into an external Vulkan secondary command buffer that is imported
+ * by the client. The secondary command buffer that gets imported must already have had begin called
+ * on it with VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT. Thus any draws to the imported
+ * command buffer cannot require changing the render pass. This requirement means that certain types
+ * of draws will not be supported when using a GrVkSecondaryCBDrawContext. This includes:
+ *     Draws that require a dst copy for blending will be dropped
+ *     Text draws will be dropped (these may require intermediate uploads of text data)
+ *     Read and Write pixels will not work
+ *     Any other draw that requires a copy will fail (this includes using backdrop filter with save
+ *         layer).
+ *     Stenciling is also disabled, but that should not restrict any actual draws from working.
+ *
+ * While using a GrVkSecondaryCBDrawContext, the client can also draw into normal SkSurfaces and
+ * then draw those SkSufaces (as SkImages) into the GrVkSecondaryCBDrawContext. If any of the
+ * previously mentioned unsupported draws are needed by the client, they can draw them into an
+ * offscreen surface, and then draw that into the GrVkSecondaryCBDrawContext.
+ *
+ * After all drawing to the GrVkSecondaryCBDrawContext has been done, the client must call flush()
+ * on the GrVkSecondaryCBDrawContext to actually fill in the secondary VkCommandBuffer with the
+ * draws.
+ *
+ * Additionally, the client must keep the GrVkSecondaryCBDrawContext alive until the secondary
+ * VkCommandBuffer has been submitted and all work finished on the GPU. Before deleting the
+ * GrVkSecondaryCBDrawContext, the client must call releaseResources() so that Skia can cleanup
+ * any internal objects that were created for the draws into the secondary command buffer.
+ */
+class SK_SPI GrVkSecondaryCBDrawContext : public SkRefCnt {
+public:
+    static sk_sp<GrVkSecondaryCBDrawContext> Make(GrRecordingContext*,
+                                                  const SkImageInfo&,
+                                                  const GrVkDrawableInfo&,
+                                                  const SkSurfaceProps* props);
+
+    ~GrVkSecondaryCBDrawContext() override;
+
+    SkCanvas* getCanvas();
+
+    // Records all the draws to the imported secondary command buffer and sets any dependent
+    // offscreen draws to the GPU.
+    void flush();
+
+    /** Inserts a list of GPU semaphores that Skia will have the driver wait on before executing
+        commands for this secondary CB. The wait semaphores will get added to the VkCommandBuffer
+        owned by this GrContext when flush() is called, and not the command buffer which the
+        Secondary CB is from. This will guarantee that the driver waits on the semaphores before
+        the secondary command buffer gets executed. If this call returns false, then the GPU
+        back end will not wait on any passed in semaphores, and the client will still own the
+        semaphores, regardless of the value of deleteSemaphoresAfterWait.
+
+        If deleteSemaphoresAfterWait is false then Skia will not delete the semaphores. In this case
+        it is the client's responsibility to not destroy or attempt to reuse the semaphores until it
+        knows that Skia has finished waiting on them. This can be done by using finishedProcs
+        on flush calls.
+
+        @param numSemaphores               size of waitSemaphores array
+        @param waitSemaphores              array of semaphore containers
+        @paramm deleteSemaphoresAfterWait  who owns and should delete the semaphores
+        @return                            true if GPU is waiting on semaphores
+    */
+    bool wait(int numSemaphores,
+              const GrBackendSemaphore waitSemaphores[],
+              bool deleteSemaphoresAfterWait = true);
+
+    // This call will release all resources held by the draw context. The client must call
+    // releaseResources() before deleting the drawing context. However, the resources also include
+    // any Vulkan resources that were created and used for draws. Therefore the client must only
+    // call releaseResources() after submitting the secondary command buffer, and waiting for it to
+    // finish on the GPU. If it is called earlier then some vulkan objects may be deleted while they
+    // are still in use by the GPU.
+    void releaseResources();
+
+    const SkSurfaceProps& props() const { return fProps; }
+
+    // TODO: Fill out these calls to support DDL
+    bool characterize(SkSurfaceCharacterization* characterization) const;
+
+#ifndef SK_DDL_IS_UNIQUE_POINTER
+    bool draw(sk_sp<const SkDeferredDisplayList> deferredDisplayList);
+#else
+    bool draw(const SkDeferredDisplayList* deferredDisplayList);
+#endif
+
+    bool isCompatible(const SkSurfaceCharacterization& characterization) const;
+
+private:
+    explicit GrVkSecondaryCBDrawContext(sk_sp<skgpu::ganesh::Device>, const SkSurfaceProps*);
+
+    sk_sp<skgpu::ganesh::Device> fDevice;
+    std::unique_ptr<SkCanvas> fCachedCanvas;
+    const SkSurfaceProps      fProps;
+
+    using INHERITED = SkRefCnt;
+};
+
+#endif

package/cpp/skia/include/private/chromium/SkChromeRemoteGlyphCache.h

@@ -13,6 +13,7 @@
 
 #include "include/core/SkData.h"
 #include "include/core/SkRefCnt.h"
+#include "include/core/SkTypeface.h"
 #include "include/utils/SkNoDrawCanvas.h"
 
 struct SkPackedGlyphID;
@@ -21,7 +22,6 @@ class SkStrikeCache;
 class SkStrikeClientImpl;
 class SkStrikeServer;
 class SkStrikeServerImpl;
-class SkTypeface;
 namespace sktext::gpu { class Slug; }
 
 using SkDiscardableHandleId = uint32_t;
@@ -62,9 +62,6 @@ public:
                                                         bool DFTSupport,
                                                         bool DFTPerspSupport = true);
 
-    // Serializes the typeface to be transmitted using this server.
-    SK_SPI sk_sp<SkData> serializeTypeface(SkTypeface*);
-
     // Serializes the strike data captured using a canvas returned by ::makeAnalysisCanvas. Any
     // handles locked using the DiscardableHandleManager will be assumed to be
     // unlocked after this call.
@@ -128,10 +125,6 @@ public:
                                    SkStrikeCache* strikeCache = nullptr);
     SK_SPI ~SkStrikeClient();
 
-    // Deserializes the typeface previously serialized using the SkStrikeServer. Returns null if the
-    // data is invalid.
-    SK_SPI sk_sp<SkTypeface> deserializeTypeface(const void* data, size_t length);
-
     // Deserializes the strike data from a SkStrikeServer. All messages generated
     // from a server when serializing the ops must be deserialized before the op
     // is rasterized.
@@ -142,9 +135,12 @@ public:
     // corresponding typefaceID on the GPU.
     SK_SPI bool translateTypefaceID(SkAutoDescriptor* descriptor) const;
 
+    // Testing helpers
+    sk_sp<SkTypeface> retrieveTypefaceUsingServerIDForTest(SkTypefaceID) const;
+
     // Given a buffer, unflatten into a slug making sure to do the typefaceID translation from
     // renderer to GPU. Returns nullptr if there was a problem.
-    sk_sp<sktext::gpu::Slug> deserializeSlug(const void* data, size_t size) const;
+    sk_sp<sktext::gpu::Slug> deserializeSlugForTest(const void* data, size_t size) const;
 
 private:
     std::unique_ptr<SkStrikeClientImpl> fImpl;

package/cpp/skia/include/private/chromium/SkDiscardableMemory.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkDiscardableMemory_DEFINED
+#define SkDiscardableMemory_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
+/**
+ *  Interface for discardable memory. Implementation is provided by the
+ *  embedder.
+ */
+class SK_SPI SkDiscardableMemory {
+public:
+    /**
+     *  Factory method that creates, initializes and locks an SkDiscardableMemory
+     *  object. If either of these steps fails, a nullptr pointer will be returned.
+     */
+    static SkDiscardableMemory* Create(size_t bytes);
+
+    /**
+     *  Factory class that creates, initializes and locks an SkDiscardableMemory
+     *  object. If either of these steps fails, a nullptr pointer will be returned.
+     */
+    class Factory : public SkRefCnt {
+    public:
+        virtual SkDiscardableMemory* create(size_t bytes) = 0;
+    private:
+        using INHERITED = SkRefCnt;
+    };
+
+    /** Must not be called while locked.
+     */
+    virtual ~SkDiscardableMemory() {}
+
+    /**
+     * Locks the memory, prevent it from being discarded. Once locked. you may
+     * obtain a pointer to that memory using the data() method.
+     *
+     * lock() may return false, indicating that the underlying memory was
+     * discarded and that the lock failed.
+     *
+     * Nested calls to lock are not allowed.
+     */
+    virtual bool SK_WARN_UNUSED_RESULT lock() = 0;
+
+    /**
+     * Returns the current pointer for the discardable memory. This call is ONLY
+     * valid when the discardable memory object is locked.
+     */
+    virtual void* data() = 0;
+
+    /**
+     * Unlock the memory so that it can be purged by the system. Must be called
+     * after every successful lock call.
+     */
+    virtual void unlock() = 0;
+
+protected:
+    SkDiscardableMemory() = default;
+    SkDiscardableMemory(const SkDiscardableMemory&) = delete;
+    SkDiscardableMemory& operator=(const SkDiscardableMemory&) = delete;
+};
+
+#endif

package/cpp/skia/include/private/chromium/Slug.h

@@ -21,14 +21,6 @@ class SkStrikeClient;
 class SkWriteBuffer;
 
 namespace sktext::gpu {
-
-// You can use Slug to simulate drawTextBlob by defining the following at compile time.
-//    SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG
-// You can use Slug serialization to simulate drawTextBlob by defining the following:
-//    SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG_SERIALIZE
-// For Skia, add this to your args.gn file.
-//    extra_cflags = ["-D", "SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG"]
-
 // Slug encapsulates an SkTextBlob at a specific origin, using a specific paint. It can be
 // manipulated using matrix and clip changes to the canvas. If the canvas is transformed, then
 // the Slug will also transform with smaller glyphs using bi-linear interpolation to render. You
@@ -70,7 +62,6 @@ private:
     static uint32_t NextUniqueID();
     const uint32_t  fUniqueID{NextUniqueID()};
 };
-
 }  // namespace sktext::gpu
 
 #endif  // sktext_gpu_Slug_DEFINED

package/cpp/skia/include/private/gpu/ganesh/GrContext_Base.h

@@ -19,6 +19,7 @@ class GrContextThreadSafeProxy;
 class GrDirectContext;
 class GrImageContext;
 class GrRecordingContext;
+enum class SkTextureCompressionType;
 
 class GrContext_Base : public SkRefCnt {
 public:
@@ -43,7 +44,7 @@ public:
      */
     SK_API GrBackendFormat defaultBackendFormat(SkColorType, GrRenderable) const;
 
-    SK_API GrBackendFormat compressedBackendFormat(SkImage::CompressionType) const;
+    SK_API GrBackendFormat compressedBackendFormat(SkTextureCompressionType) const;
 
     /**
      * Gets the maximum supported sample count for a color type. 1 is returned if only non-MSAA

package/cpp/skia/include/private/gpu/ganesh/GrD3DTypesMinimal.h

@@ -65,7 +65,7 @@ public:
 
     GrD3DSurfaceInfo getSurfaceInfo(uint32_t sampleCount,
                                     uint32_t levelCount,
-                                    GrProtected isProtected) const;
+                                    skgpu::Protected isProtected) const;
 
 private:
     GrD3DTextureResourceSpec* fSpec;

package/cpp/skia/include/private/gpu/ganesh/GrDawnTypesPriv.h

@@ -20,7 +20,7 @@ struct GrDawnTextureSpec {
 GrDawnSurfaceInfo GrDawnTextureSpecToSurfaceInfo(const GrDawnTextureSpec& dawnSpec,
                                                  uint32_t sampleCount,
                                                  uint32_t levelCount,
-                                                 GrProtected isProtected);
+                                                 skgpu::Protected isProtected);
 
 #endif
 

package/cpp/skia/include/private/gpu/ganesh/GrGLTypesPriv.h

@@ -103,6 +103,6 @@ struct GrGLTextureSpec {
 GrGLSurfaceInfo GrGLTextureSpecToSurfaceInfo(const GrGLTextureSpec& glSpec,
                                              uint32_t sampleCount,
                                              uint32_t levelCount,
-                                             GrProtected isProtected);
+                                             skgpu::Protected isProtected);
 
 #endif

package/cpp/skia/include/private/gpu/ganesh/GrImageContext.h

@@ -8,7 +8,7 @@
 #ifndef GrImageContext_DEFINED
 #define GrImageContext_DEFINED
 
-#include "include/private/SingleOwner.h"
+#include "include/private/base/SingleOwner.h"
 #include "include/private/gpu/ganesh/GrContext_Base.h"
 
 class GrImageContextPriv;

package/cpp/skia/include/private/gpu/ganesh/GrMockTypesPriv.h

@@ -8,18 +8,19 @@
 #ifndef GrMockTypesPriv_DEFINED
 #define GrMockTypesPriv_DEFINED
 
+#include "include/core/SkTextureCompressionType.h"
 #include "include/gpu/mock/GrMockTypes.h"
 
 struct GrMockTextureSpec {
     GrMockTextureSpec()
             : fColorType(GrColorType::kUnknown)
-             , fCompressionType(SkImage::CompressionType::kNone) {}
+             , fCompressionType(SkTextureCompressionType::kNone) {}
     GrMockTextureSpec(const GrMockSurfaceInfo& info)
             : fColorType(info.fColorType)
             , fCompressionType(info.fCompressionType) {}
 
     GrColorType fColorType = GrColorType::kUnknown;
-    SkImage::CompressionType fCompressionType = SkImage::CompressionType::kNone;
+    SkTextureCompressionType fCompressionType = SkTextureCompressionType::kNone;
 };
 
 GrMockSurfaceInfo GrMockTextureSpecToSurfaceInfo(const GrMockTextureSpec& mockSpec,

package/cpp/skia/include/private/gpu/ganesh/GrMtlTypesPriv.h

@@ -68,7 +68,7 @@ struct GrMtlTextureSpec {
 GrMtlSurfaceInfo GrMtlTextureSpecToSurfaceInfo(const GrMtlTextureSpec& mtlSpec,
                                                uint32_t sampleCount,
                                                uint32_t levelCount,
-                                               GrProtected isProtected);
+                                               skgpu::Protected isProtected);
 
 #endif  // __APPLE__
 

package/cpp/skia/include/private/gpu/ganesh/GrTypesPriv.h

@@ -8,28 +8,21 @@
 #ifndef GrTypesPriv_DEFINED
 #define GrTypesPriv_DEFINED
 
-#include <chrono>
-#include "include/core/SkImage.h"
+#include "include/core/SkColor.h"
 #include "include/core/SkImageInfo.h"
 #include "include/core/SkPath.h"
 #include "include/core/SkRefCnt.h"
+#include "include/core/SkTextureCompressionType.h"
 #include "include/gpu/GrTypes.h"
-#include "include/private/SkImageInfoPriv.h"
-#include "include/private/SkMacros.h"
+#include "include/private/base/SkMacros.h"
+#include "include/private/base/SkTypeTraits.h"
+
+#include <functional>
 
 class GrBackendFormat;
 class GrCaps;
 class GrSurfaceProxy;
 
-// The old libstdc++ uses the draft name "monotonic_clock" rather than "steady_clock". This might
-// not actually be monotonic, depending on how libstdc++ was built. However, this is only currently
-// used for idle resource purging so it shouldn't cause a correctness problem.
-#if defined(__GLIBCXX__) && (__GLIBCXX__ < 20130000)
-using GrStdSteadyClock = std::chrono::monotonic_clock;
-#else
-using GrStdSteadyClock = std::chrono::steady_clock;
-#endif
-
 /**
  *  divide, rounding up
  */
@@ -643,6 +636,7 @@ static constexpr GrColorType SkColorTypeToGrColorType(SkColorType ct) {
         case kRGB_101010x_SkColorType:        return GrColorType::kUnknown;
         case kBGRA_1010102_SkColorType:       return GrColorType::kBGRA_1010102;
         case kBGR_101010x_SkColorType:        return GrColorType::kUnknown;
+        case kBGR_101010x_XR_SkColorType:     return GrColorType::kUnknown;
         case kRGBA_F32_SkColorType:           return GrColorType::kRGBA_F32;
         case kR8G8_unorm_SkColorType:         return GrColorType::kRG_88;
         case kA16_unorm_SkColorType:          return GrColorType::kAlpha_16;
@@ -924,12 +918,12 @@ static constexpr size_t GrColorTypeBytesPerPixel(GrColorType ct) {
 
 // In general we try to not mix CompressionType and ColorType, but currently SkImage still requires
 // an SkColorType even for CompressedTypes so we need some conversion.
-static constexpr SkColorType GrCompressionTypeToSkColorType(SkImage::CompressionType compression) {
+static constexpr SkColorType GrCompressionTypeToSkColorType(SkTextureCompressionType compression) {
     switch (compression) {
-        case SkImage::CompressionType::kNone:            return kUnknown_SkColorType;
-        case SkImage::CompressionType::kETC2_RGB8_UNORM: return kRGB_888x_SkColorType;
-        case SkImage::CompressionType::kBC1_RGB8_UNORM:  return kRGB_888x_SkColorType;
-        case SkImage::CompressionType::kBC1_RGBA8_UNORM: return kRGBA_8888_SkColorType;
+        case SkTextureCompressionType::kNone:            return kUnknown_SkColorType;
+        case SkTextureCompressionType::kETC2_RGB8_UNORM: return kRGB_888x_SkColorType;
+        case SkTextureCompressionType::kBC1_RGB8_UNORM:  return kRGB_888x_SkColorType;
+        case SkTextureCompressionType::kBC1_RGBA8_UNORM: return kRGBA_8888_SkColorType;
     }
 
     SkUNREACHABLE;
@@ -995,12 +989,12 @@ static constexpr const char* GrColorTypeToStr(GrColorType ct) {
     SkUNREACHABLE;
 }
 
-static constexpr const char* GrCompressionTypeToStr(SkImage::CompressionType compression) {
+static constexpr const char* GrCompressionTypeToStr(SkTextureCompressionType compression) {
     switch (compression) {
-        case SkImage::CompressionType::kNone:            return "kNone";
-        case SkImage::CompressionType::kETC2_RGB8_UNORM: return "kETC2_RGB8_UNORM";
-        case SkImage::CompressionType::kBC1_RGB8_UNORM:  return "kBC1_RGB8_UNORM";
-        case SkImage::CompressionType::kBC1_RGBA8_UNORM: return "kBC1_RGBA8_UNORM";
+        case SkTextureCompressionType::kNone:            return "kNone";
+        case SkTextureCompressionType::kETC2_RGB8_UNORM: return "kETC2_RGB8_UNORM";
+        case SkTextureCompressionType::kBC1_RGB8_UNORM:  return "kBC1_RGB8_UNORM";
+        case SkTextureCompressionType::kBC1_RGBA8_UNORM: return "kBC1_RGBA8_UNORM";
     }
     SkUNREACHABLE;
 }

package/cpp/skia/include/private/gpu/ganesh/GrVkTypesPriv.h

@@ -35,7 +35,7 @@ struct GrVkBackendSurfaceInfo {
 
     GrVkImageInfo snapImageInfo(const skgpu::MutableTextureStateRef*) const;
 
-    bool isProtected() const { return fImageInfo.fProtected == GrProtected::kYes; }
+    bool isProtected() const { return fImageInfo.fProtected == skgpu::Protected::kYes; }
 #if GR_TEST_UTILS
     bool operator==(const GrVkBackendSurfaceInfo& that) const;
 #endif
@@ -68,6 +68,6 @@ struct GrVkImageSpec {
 GrVkSurfaceInfo GrVkImageSpecToSurfaceInfo(const GrVkImageSpec& vkSpec,
                                            uint32_t sampleCount,
                                            uint32_t levelCount,
-                                           GrProtected isProtected);
+                                           skgpu::Protected isProtected);
 
 #endif

package/cpp/skia/include/private/gpu/graphite/DawnTypesPriv.h

@@ -0,0 +1,38 @@
+/*
+ * 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_DawnTypesPriv_DEFINED
+#define skgpu_graphite_DawnTypesPriv_DEFINED
+
+#include "include/gpu/graphite/dawn/DawnTypes.h"
+
+namespace skgpu::graphite {
+
+struct DawnTextureSpec {
+    DawnTextureSpec()
+            : fFormat(wgpu::TextureFormat::Undefined)
+            , fUsage(wgpu::TextureUsage::None) {}
+    DawnTextureSpec(const DawnTextureInfo& info)
+            : fFormat(info.fFormat)
+            , fUsage(info.fUsage) {}
+
+    bool operator==(const DawnTextureSpec& that) const {
+        return fUsage == that.fUsage &&
+               fFormat == that.fFormat;
+    }
+
+    wgpu::TextureFormat fFormat;
+    wgpu::TextureUsage fUsage;
+};
+
+DawnTextureInfo DawnTextureSpecToTextureInfo(const DawnTextureSpec& dawnSpec,
+                                             uint32_t sampleCount,
+                                             Mipmapped mipmapped);
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_DawnTypesPriv_DEFINED

package/cpp/skia/include/private/gpu/graphite/{MtlTypesPriv.h → MtlGraphiteTypesPriv.h}

@@ -5,11 +5,11 @@
  * found in the LICENSE file.
  */
 
-#ifndef skgpu_graphite_MtlTypesPriv_DEFINED
-#define skgpu_graphite_MtlTypesPriv_DEFINED
+#ifndef skgpu_graphite_MtlGraphiteTypesPriv_DEFINED
+#define skgpu_graphite_MtlGraphiteTypesPriv_DEFINED
 
 #include "include/gpu/graphite/GraphiteTypes.h"
-#include "include/gpu/graphite/mtl/MtlTypes.h"
+#include "include/gpu/graphite/mtl/MtlGraphiteTypes.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -67,8 +67,8 @@ struct MtlTextureSpec {
 
 MtlTextureInfo MtlTextureSpecToTextureInfo(const MtlTextureSpec& mtlSpec,
                                            uint32_t sampleCount,
-                                           uint32_t levelCount);
+                                           Mipmapped mipmapped);
 
 }  // namespace skgpu::graphite
 
-#endif  // skgpu_graphite_MtlTypesPriv_DEFINED
+#endif  // skgpu_graphite_MtlGraphiteTypesPriv_DEFINED

package/cpp/skia/include/private/gpu/graphite/VulkanGraphiteTypesPriv.h

@@ -19,8 +19,6 @@ struct VulkanTextureSpec {
             , fImageTiling(VK_IMAGE_TILING_OPTIMAL)
             , fImageUsageFlags(0)
             , fSharingMode(VK_SHARING_MODE_EXCLUSIVE)
-            , fCurrentQueueFamily(VK_QUEUE_FAMILY_IGNORED)
-            , fImageLayout(VK_IMAGE_LAYOUT_UNDEFINED)
             , fAspectMask(VK_IMAGE_ASPECT_COLOR_BIT) {}
     VulkanTextureSpec(const VulkanTextureInfo& info)
             : fFlags(info.fFlags)
@@ -28,8 +26,6 @@ struct VulkanTextureSpec {
             , fImageTiling(info.fImageTiling)
             , fImageUsageFlags(info.fImageUsageFlags)
             , fSharingMode(info.fSharingMode)
-            , fCurrentQueueFamily(info.fCurrentQueueFamily)
-            , fImageLayout(info.fImageLayout)
             , fAspectMask(info.fAspectMask) {}
 
     bool operator==(const VulkanTextureSpec& that) const {
@@ -38,8 +34,6 @@ struct VulkanTextureSpec {
                fImageTiling == that.fImageTiling &&
                fImageUsageFlags == that.fImageUsageFlags &&
                fSharingMode == that.fSharingMode &&
-               fCurrentQueueFamily == that.fCurrentQueueFamily &&
-               fImageLayout == that.fImageLayout &&
                fAspectMask == that.fAspectMask;
     }
 
@@ -48,15 +42,13 @@ struct VulkanTextureSpec {
     VkImageTiling            fImageTiling;
     VkImageUsageFlags        fImageUsageFlags;
     VkSharingMode            fSharingMode;
-    uint32_t                 fCurrentQueueFamily;
-    VkImageLayout            fImageLayout;
     VkImageAspectFlags       fAspectMask;
     // GrVkYcbcrConversionInfo  fYcbcrConversionInfo;
 };
 
 VulkanTextureInfo VulkanTextureSpecToTextureInfo(const VulkanTextureSpec& vkSpec,
                                                  uint32_t sampleCount,
-                                                 uint32_t levelCount);
+                                                 Mipmapped mipmapped);
 
 } // namespace skgpu::graphite
 

package/cpp/skia/include/private/gpu/vk/SkiaVulkan.h

@@ -10,6 +10,8 @@
 
 #include "include/core/SkTypes.h"
 
+// IWYU pragma: begin_exports
+
 #if SKIA_IMPLEMENTATION || !defined(SK_VULKAN)
 #include "include/third_party/vulkan/vulkan/vulkan_core.h"
 #else
@@ -29,4 +31,6 @@
 #endif
 #endif
 
+// IWYU pragma: end_exports
+
 #endif

package/cpp/skia/include/utils/SkCamera.h

@@ -14,7 +14,7 @@
 #include "include/core/SkMatrix.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkTypes.h"
-#include "include/private/SkNoncopyable.h"
+#include "include/private/base/SkNoncopyable.h"
 
 // NOTE -- This entire header / impl is deprecated, and will be removed from Skia soon.
 //

package/cpp/skia/include/utils/SkCustomTypeface.h

@@ -14,12 +14,15 @@
 #include "include/core/SkPath.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
+#include "include/core/SkTypeface.h"
 #include "include/core/SkTypes.h"
 
+#include <memory>
 #include <vector>
 
 class SkStream;
-class SkTypeface;
+class SkStreamAsset;
+struct SkFontArguments;
 
 class SK_API SkCustomTypefaceBuilder {
 public:
@@ -33,6 +36,9 @@ public:
 
     sk_sp<SkTypeface> detach();
 
+    static constexpr SkTypeface::FactoryId FactoryId = SkSetFourByteTag('u','s','e','r');
+    static sk_sp<SkTypeface> MakeFromStream(std::unique_ptr<SkStreamAsset>, const SkFontArguments&);
+
 private:
     struct GlyphRec {
         // logical union