@shopify/react-native-skia 0.1.233 → 0.1.236

package/cpp/skia/include/private/base/SkTArray.h

@@ -185,9 +185,8 @@ public:
     bool empty() const { return fSize == 0; }
 
     /**
-     * Adds 1 new default-initialized T value and returns it by reference. Note
-     * the reference only remains valid until the next call that adds or removes
-     * elements.
+     * Adds one new default-initialized T value and returns it by reference. Note that the reference
+     * only remains valid until the next call that adds or removes elements.
      */
     T& push_back() {
         void* newT = this->push_back_raw(1);
@@ -195,27 +194,52 @@ public:
     }
 
     /**
-     * Version of above that uses a copy constructor to initialize the new item
+     * Adds one new T value which is copy-constructed, returning it by reference. As always,
+     * the reference only remains valid until the next call that adds or removes elements.
      */
     T& push_back(const T& t) {
-        void* newT = this->push_back_raw(1);
-        return *new (newT) T(t);
+        T* newT;
+        if (this->capacity() > fSize) SK_LIKELY {
+            // Copy over the element directly.
+            newT = new (fData + fSize) T(t);
+        } else {
+            newT = this->growAndConstructAtEnd(t);
+        }
+
+        fSize += 1;
+        return *newT;
     }
 
     /**
-     * Version of above that uses a move constructor to initialize the new item
+     * Adds one new T value which is copy-constructed, returning it by reference.
      */
     T& push_back(T&& t) {
-        void* newT = this->push_back_raw(1);
-        return *new (newT) T(std::move(t));
+        T* newT;
+        if (this->capacity() > fSize) SK_LIKELY {
+            // Move over the element directly.
+            newT = new (fData + fSize) T(std::move(t));
+        } else {
+            newT = this->growAndConstructAtEnd(std::move(t));
+        }
+
+        fSize += 1;
+        return *newT;
     }
 
     /**
-     *  Construct a new T at the back of this array.
+     *  Constructs a new T at the back of this array, returning it by reference.
      */
-    template<class... Args> T& emplace_back(Args&&... args) {
-        void* newT = this->push_back_raw(1);
-        return *new (newT) T(std::forward<Args>(args)...);
+    template <typename... Args> T& emplace_back(Args&&... args) {
+        T* newT;
+        if (this->capacity() > fSize) SK_LIKELY {
+            // Emplace the new element in directly.
+            newT = new (fData + fSize) T(std::forward<Args>(args)...);
+        } else {
+            newT = this->growAndConstructAtEnd(std::forward<Args>(args)...);
+        }
+
+        fSize += 1;
+        return *newT;
     }
 
     /**
@@ -297,13 +321,15 @@ public:
     }
 
     /**
-     * Pushes or pops from the back to resize. Pushes will be default
-     * initialized.
+     * Pushes or pops from the back to resize. Pushes will be default initialized.
      */
     void resize_back(int newCount) {
         SkASSERT(newCount >= 0);
-
         if (newCount > this->size()) {
+            if (this->empty()) {
+                // When the container is completely empty, grow to exactly the requested size.
+                this->checkRealloc(newCount, kExactFit);
+            }
             this->push_back_n(newCount - fSize);
         } else if (newCount < this->size()) {
             this->pop_back_n(fSize - newCount);
@@ -357,7 +383,7 @@ public:
     T* data() { return fData; }
     const T* data() const { return fData; }
     int size() const { return fSize; }
-    size_t size_bytes() const { return this->bytes(fSize); }
+    size_t size_bytes() const { return Bytes(fSize); }
     void resize(size_t count) { this->resize_back((int)count); }
 
     void clear() {
@@ -503,7 +529,7 @@ private:
         // to a full divide instruction. If done here the size is known at compile, and usually
         // can be implemented by a right shift. The full divide takes ~50X longer than the shift.
         size_t size = std::min(allocation.size() / sizeof(T), SkToSizeT(kMaxCapacity));
-        setData(SkSpan<T>(data, size));
+        this->setData(SkSpan<T>(data, size));
     }
 
     void setData(SkSpan<T> array) {
@@ -524,7 +550,7 @@ private:
         return (T*)buffer;
     }
 
-    size_t bytes(int n) const {
+    static size_t Bytes(int n) {
         SkASSERT(n <= kMaxCapacity);
         return SkToSizeT(n) * sizeof(T);
     }
@@ -577,10 +603,10 @@ private:
 
     void move(void* dst) {
         if constexpr (MEM_MOVE) {
-            sk_careful_memcpy(dst, fData, this->bytes(fSize));
+            sk_careful_memcpy(dst, fData, Bytes(fSize));
         } else {
             for (int i = 0; i < this->size(); ++i) {
-                new (static_cast<char*>(dst) + this->bytes(i)) T(std::move(fData[i]));
+                new (static_cast<char*>(dst) + Bytes(i)) T(std::move(fData[i]));
                 fData[i].~T();
             }
         }
@@ -595,17 +621,31 @@ private:
         return ptr;
     }
 
+    template <typename... Args>
+    SK_ALWAYS_INLINE T* growAndConstructAtEnd(Args&&... args) {
+        SkSpan<std::byte> buffer = this->preallocateNewData(/*delta=*/1, kGrowing);
+        T* newT = new (TCast(buffer.data()) + fSize) T(std::forward<Args>(args)...);
+        this->installDataAndUpdateCapacity(buffer);
+
+        return newT;
+    }
+
     void checkRealloc(int delta, double growthFactor) {
-        // This constant needs to be declared in the function where it is used to work around
-        // MSVC's persnickety nature about template definitions.
         SkASSERT(delta >= 0);
         SkASSERT(fSize >= 0);
         SkASSERT(fCapacity >= 0);
 
-        // Return if there are enough remaining allocated elements to satisfy the request.
-        if (this->capacity() - fSize >= delta) {
-            return;
+        // Check if there are enough remaining allocated elements to satisfy the request.
+        if (this->capacity() - fSize < delta) {
+            // Looks like we need to reallocate.
+            this->installDataAndUpdateCapacity(this->preallocateNewData(delta, growthFactor));
         }
+    }
+
+    SkSpan<std::byte> preallocateNewData(int delta, double growthFactor) {
+        SkASSERT(delta >= 0);
+        SkASSERT(fSize >= 0);
+        SkASSERT(fCapacity >= 0);
 
         // Don't overflow fSize or size_t later in the memory allocation. Overflowing memory
         // allocation really only applies to fSizes on 32-bit machines; on 64-bit machines this
@@ -616,14 +656,15 @@ private:
         }
         const int newCount = fSize + delta;
 
-        SkSpan<std::byte> allocation = Allocate(newCount, growthFactor);
+        return Allocate(newCount, growthFactor);
+    }
 
+    void installDataAndUpdateCapacity(SkSpan<std::byte> allocation) {
         this->move(TCast(allocation.data()));
         if (fOwnMemory) {
             sk_free(fData);
         }
         this->setDataFromBytes(allocation);
-        SkASSERT(this->capacity() >= newCount);
         SkASSERT(fData != nullptr);
     }
 

package/cpp/skia/include/private/base/SkThreadAnnotations.h

@@ -8,6 +8,8 @@
 #ifndef SkThreadAnnotations_DEFINED
 #define SkThreadAnnotations_DEFINED
 
+#include "include/private/base/SkFeatures.h"  // IWYU pragma: keep
+
 // The bulk of this code is cribbed from:
 // http://clang.llvm.org/docs/ThreadSafetyAnalysis.html
 
@@ -76,13 +78,24 @@
 #define SK_NO_THREAD_SAFETY_ANALYSIS \
   SK_THREAD_ANNOTATION_ATTRIBUTE(no_thread_safety_analysis)
 
-#if defined(SK_BUILD_FOR_GOOGLE3) && !defined(SK_BUILD_FOR_WASM_IN_GOOGLE3)
+#if defined(SK_BUILD_FOR_GOOGLE3) && !defined(SK_BUILD_FOR_WASM_IN_GOOGLE3) \
+    && !defined(SK_BUILD_FOR_WIN)
     extern "C" {
-        void __google_cxa_guard_acquire_begin(void);
-        void __google_cxa_guard_acquire_end  (void);
+        void __google_cxa_guard_acquire_begin(void) __attribute__((weak));
+        void __google_cxa_guard_acquire_end  (void) __attribute__((weak));
+    }
+    static inline void sk_potentially_blocking_region_begin() {
+        if (&__google_cxa_guard_acquire_begin) {
+            __google_cxa_guard_acquire_begin();
+        }
+    }
+    static inline void sk_potentially_blocking_region_end() {
+        if (&__google_cxa_guard_acquire_end) {
+            __google_cxa_guard_acquire_end();
+        }
     }
-    #define SK_POTENTIALLY_BLOCKING_REGION_BEGIN __google_cxa_guard_acquire_begin()
-    #define SK_POTENTIALLY_BLOCKING_REGION_END   __google_cxa_guard_acquire_end()
+    #define SK_POTENTIALLY_BLOCKING_REGION_BEGIN sk_potentially_blocking_region_begin()
+    #define SK_POTENTIALLY_BLOCKING_REGION_END   sk_potentially_blocking_region_end()
 #else
     #define SK_POTENTIALLY_BLOCKING_REGION_BEGIN
     #define SK_POTENTIALLY_BLOCKING_REGION_END

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

@@ -34,7 +34,6 @@
 class SK_API GrSurfaceCharacterization {
 public:
     enum class Textureable : bool { kNo = false, kYes = true };
-    enum class MipMapped : bool { kNo = false, kYes = true };
     enum class UsesGLFBO0 : bool { kNo = false, kYes = true };
     // This flag indicates that the backing VkImage for this Vulkan surface will have the
     // VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set. This bit allows skia to handle advanced blends
@@ -48,12 +47,11 @@ public:
             , fOrigin(kBottomLeft_GrSurfaceOrigin)
             , fSampleCnt(0)
             , fIsTextureable(Textureable::kYes)
-            , fIsMipMapped(MipMapped::kYes)
+            , fIsMipmapped(skgpu::Mipmapped::kYes)
             , fUsesGLFBO0(UsesGLFBO0::kNo)
             , fVulkanSecondaryCBCompatible(VulkanSecondaryCBCompatible::kNo)
-            , fIsProtected(GrProtected::kNo)
-            , fSurfaceProps(0, kUnknown_SkPixelGeometry) {
-    }
+            , fIsProtected(skgpu::Protected::kNo)
+            , fSurfaceProps() {}
 
     GrSurfaceCharacterization(GrSurfaceCharacterization&&) = default;
     GrSurfaceCharacterization& operator=(GrSurfaceCharacterization&&) = default;
@@ -103,7 +101,7 @@ public:
     SkColorType colorType() const { return fImageInfo.colorType(); }
     int sampleCount() const { return fSampleCnt; }
     bool isTextureable() const { return Textureable::kYes == fIsTextureable; }
-    bool isMipMapped() const { return MipMapped::kYes == fIsMipMapped; }
+    bool isMipMapped() const { return skgpu::Mipmapped::kYes == fIsMipmapped; }
     bool usesGLFBO0() const { return UsesGLFBO0::kYes == fUsesGLFBO0; }
     bool vkRTSupportsInputAttachment() const {
         return VkRTSupportsInputAttachment::kYes == fVkRTSupportsInputAttachment;
@@ -111,36 +109,34 @@ public:
     bool vulkanSecondaryCBCompatible() const {
         return VulkanSecondaryCBCompatible::kYes == fVulkanSecondaryCBCompatible;
     }
-    GrProtected isProtected() const { return fIsProtected; }
+    skgpu::Protected isProtected() const { return fIsProtected; }
     SkColorSpace* colorSpace() const { return fImageInfo.colorSpace(); }
     sk_sp<SkColorSpace> refColorSpace() const { return fImageInfo.refColorSpace(); }
     const SkSurfaceProps& surfaceProps()const { return fSurfaceProps; }
 
-    // Is the provided backend texture compatible with this surface characterization?
-    bool isCompatible(const GrBackendTexture&) const;
-
 private:
     friend class SkSurface_Ganesh;           // for 'set' & 'config'
     friend class GrVkSecondaryCBDrawContext; // for 'set' & 'config'
     friend class GrContextThreadSafeProxy; // for private ctor
+    friend class GrVkContextThreadSafeProxy;    // for private ctor
     friend class GrDeferredDisplayListRecorder; // for 'config'
     friend class SkSurface; // for 'config'
 
     SkDEBUGCODE(void validate() const;)
 
-    GrSurfaceCharacterization(sk_sp<GrContextThreadSafeProxy> contextInfo,
-                              size_t cacheMaxResourceBytes,
-                              const SkImageInfo& ii,
-                              const GrBackendFormat& backendFormat,
-                              GrSurfaceOrigin origin,
-                              int sampleCnt,
-                              Textureable isTextureable,
-                              MipMapped isMipMapped,
-                              UsesGLFBO0 usesGLFBO0,
-                              VkRTSupportsInputAttachment vkRTSupportsInputAttachment,
-                              VulkanSecondaryCBCompatible vulkanSecondaryCBCompatible,
-                              GrProtected isProtected,
-                              const SkSurfaceProps& surfaceProps)
+            GrSurfaceCharacterization(sk_sp<GrContextThreadSafeProxy> contextInfo,
+                                      size_t cacheMaxResourceBytes,
+                                      const SkImageInfo& ii,
+                                      const GrBackendFormat& backendFormat,
+                                      GrSurfaceOrigin origin,
+                                      int sampleCnt,
+                                      Textureable isTextureable,
+                                      skgpu::Mipmapped isMipmapped,
+                                      UsesGLFBO0 usesGLFBO0,
+                                      VkRTSupportsInputAttachment vkRTSupportsInputAttachment,
+                                      VulkanSecondaryCBCompatible vulkanSecondaryCBCompatible,
+                                      skgpu::Protected isProtected,
+                                      const SkSurfaceProps& surfaceProps)
             : fContextInfo(std::move(contextInfo))
             , fCacheMaxResourceBytes(cacheMaxResourceBytes)
             , fImageInfo(ii)
@@ -148,7 +144,7 @@ private:
             , fOrigin(origin)
             , fSampleCnt(sampleCnt)
             , fIsTextureable(isTextureable)
-            , fIsMipMapped(isMipMapped)
+            , fIsMipmapped(isMipmapped)
             , fUsesGLFBO0(usesGLFBO0)
             , fVkRTSupportsInputAttachment(vkRTSupportsInputAttachment)
             , fVulkanSecondaryCBCompatible(vulkanSecondaryCBCompatible)
@@ -168,17 +164,17 @@ private:
              GrSurfaceOrigin origin,
              int sampleCnt,
              Textureable isTextureable,
-             MipMapped isMipMapped,
+             skgpu::Mipmapped isMipmapped,
              UsesGLFBO0 usesGLFBO0,
              VkRTSupportsInputAttachment vkRTSupportsInputAttachment,
              VulkanSecondaryCBCompatible vulkanSecondaryCBCompatible,
-             GrProtected isProtected,
+             skgpu::Protected isProtected,
              const SkSurfaceProps& surfaceProps) {
         if (surfaceProps.flags() & SkSurfaceProps::kDynamicMSAA_Flag) {
             // Dynamic MSAA is not currently supported with DDL.
             *this = {};
         } else {
-            fContextInfo = contextInfo;
+            fContextInfo = std::move(contextInfo);
             fCacheMaxResourceBytes = cacheMaxResourceBytes;
 
             fImageInfo = ii;
@@ -186,7 +182,7 @@ private:
             fOrigin = origin;
             fSampleCnt = sampleCnt;
             fIsTextureable = isTextureable;
-            fIsMipMapped = isMipMapped;
+            fIsMipmapped = isMipmapped;
             fUsesGLFBO0 = usesGLFBO0;
             fVkRTSupportsInputAttachment = vkRTSupportsInputAttachment;
             fVulkanSecondaryCBCompatible = vulkanSecondaryCBCompatible;
@@ -204,11 +200,11 @@ private:
     GrSurfaceOrigin                 fOrigin;
     int                             fSampleCnt;
     Textureable                     fIsTextureable;
-    MipMapped                       fIsMipMapped;
+    skgpu::Mipmapped                fIsMipmapped;
     UsesGLFBO0                      fUsesGLFBO0;
     VkRTSupportsInputAttachment     fVkRTSupportsInputAttachment;
     VulkanSecondaryCBCompatible     fVulkanSecondaryCBCompatible;
-    GrProtected                     fIsProtected;
+    skgpu::Protected                fIsProtected;
     SkSurfaceProps                  fSurfaceProps;
 };
 

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

@@ -78,9 +78,10 @@ public:
         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.
+        the secondary command buffer gets executed. We will submit the semphore to wait at
+        VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT and VK_PIPELINE_STAGE_TRANSFER_BIT. 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

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

@@ -108,7 +108,7 @@ SK_API sk_sp<SkImage> PromiseTextureFromYUVA(sk_sp<GrContextThreadSafeProxy> gpu
     around forever.
 */
 SK_API GrDirectContext* GetContext(const SkImage* src);
-inline GrDirectContext* GetContext(sk_sp<const SkImage> src) {
+inline GrDirectContext* GetContext(const sk_sp<const SkImage>& src) {
     return GetContext(src.get());
 }
 

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

@@ -500,11 +500,6 @@ enum class GrBackendObjectOwnership : bool {
     kOwned = true
 };
 
-/*
- * Object for CPU-GPU synchronization
- */
-typedef uint64_t GrFence;
-
 /**
  * Used to include or exclude specific GPU path renderers for testing purposes.
  */
@@ -546,6 +541,7 @@ enum class GrColorType {
     kUnknown,
     kAlpha_8,
     kBGR_565,
+    kRGB_565,
     kABGR_4444,  // This name differs from SkColorType. kARGB_4444_SkColorType is misnamed.
     kRGBA_8888,
     kRGBA_8888_SRGB,
@@ -595,6 +591,7 @@ static constexpr SkColorType GrColorTypeToSkColorType(GrColorType ct) {
         case GrColorType::kUnknown:          return kUnknown_SkColorType;
         case GrColorType::kAlpha_8:          return kAlpha_8_SkColorType;
         case GrColorType::kBGR_565:          return kRGB_565_SkColorType;
+        case GrColorType::kRGB_565:          return kUnknown_SkColorType;
         case GrColorType::kABGR_4444:        return kARGB_4444_SkColorType;
         case GrColorType::kRGBA_8888:        return kRGBA_8888_SkColorType;
         case GrColorType::kRGBA_8888_SRGB:   return kSRGBA_8888_SkColorType;
@@ -665,6 +662,7 @@ static constexpr uint32_t GrColorTypeChannelFlags(GrColorType ct) {
         case GrColorType::kUnknown:          return 0;
         case GrColorType::kAlpha_8:          return kAlpha_SkColorChannelFlag;
         case GrColorType::kBGR_565:          return kRGB_SkColorChannelFlags;
+        case GrColorType::kRGB_565:          return kRGB_SkColorChannelFlags;
         case GrColorType::kABGR_4444:        return kRGBA_SkColorChannelFlags;
         case GrColorType::kRGBA_8888:        return kRGBA_SkColorChannelFlags;
         case GrColorType::kRGBA_8888_SRGB:   return kRGBA_SkColorChannelFlags;
@@ -800,6 +798,8 @@ static constexpr GrColorFormatDesc GrGetColorTypeDesc(GrColorType ct) {
             return GrColorFormatDesc::MakeAlpha(8, GrColorTypeEncoding::kUnorm);
         case GrColorType::kBGR_565:
             return GrColorFormatDesc::MakeRGB(5, 6, 5, GrColorTypeEncoding::kUnorm);
+        case GrColorType::kRGB_565:
+            return GrColorFormatDesc::MakeRGB(5, 6, 5, GrColorTypeEncoding::kUnorm);
         case GrColorType::kABGR_4444:
             return GrColorFormatDesc::MakeRGBA(4, GrColorTypeEncoding::kUnorm);
         case GrColorType::kRGBA_8888:
@@ -897,6 +897,7 @@ static constexpr size_t GrColorTypeBytesPerPixel(GrColorType ct) {
         case GrColorType::kUnknown:          return 0;
         case GrColorType::kAlpha_8:          return 1;
         case GrColorType::kBGR_565:          return 2;
+        case GrColorType::kRGB_565:          return 2;
         case GrColorType::kABGR_4444:        return 2;
         case GrColorType::kRGBA_8888:        return 4;
         case GrColorType::kRGBA_8888_SRGB:   return 4;
@@ -970,7 +971,8 @@ static constexpr const char* GrColorTypeToStr(GrColorType ct) {
     switch (ct) {
         case GrColorType::kUnknown:          return "kUnknown";
         case GrColorType::kAlpha_8:          return "kAlpha_8";
-        case GrColorType::kBGR_565:          return "kRGB_565";
+        case GrColorType::kBGR_565:          return "kBGR_565";
+        case GrColorType::kRGB_565:          return "kRGB_565";
         case GrColorType::kABGR_4444:        return "kABGR_4444";
         case GrColorType::kRGBA_8888:        return "kRGBA_8888";
         case GrColorType::kRGBA_8888_SRGB:   return "kRGBA_8888_SRGB";

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

@@ -10,6 +10,33 @@
 
 namespace skgpu::graphite {
 
+/**
+ * Used to include or exclude a specific path rendering technique for testing purposes.
+ */
+enum class PathRendererStrategy {
+    /**
+     * Graphite selects the best path rendering technique for each shape. This is the default
+     * behavior.
+     */
+    kDefault,
+
+    /**
+     * All paths are rasterized into coverage masks using a GPU compute approach. This method
+     * always uses analytic anti-aliasing.
+     */
+    kComputeAnalyticAA,
+
+    /**
+     * All paths are rasterized into coverage masks using the CPU raster backend.
+     */
+    kRasterAA,
+
+    /**
+     * Render paths using tessellation and stencil-and-cover.
+     */
+    kTessellation,
+};
+
 /**
  * Private options that are only meant for testing within Skia's tools.
  */
@@ -27,6 +54,8 @@ struct ContextOptionsPriv {
      * that created it. Used by readPixels() and other methods that normally require a Context.
      */
     bool fStoreContextRefInRecorder = false;
+
+    PathRendererStrategy fPathRendererStrategy = PathRendererStrategy::kDefault;
 };
 
 }  // namespace skgpu::graphite

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

@@ -16,30 +16,33 @@ namespace skgpu::graphite {
 struct DawnTextureSpec {
     DawnTextureSpec()
             : fFormat(wgpu::TextureFormat::Undefined)
-            , fUsage(wgpu::TextureUsage::None) {}
+            , fUsage(wgpu::TextureUsage::None)
+            , fAspect(wgpu::TextureAspect::All) {}
     DawnTextureSpec(const DawnTextureInfo& info)
-            : fFormat(info.fFormat)
-            , fUsage(info.fUsage) {}
+            : fFormat(info.fFormat), fUsage(info.fUsage), fAspect(info.fAspect) {}
 
     bool operator==(const DawnTextureSpec& that) const {
-        return fUsage == that.fUsage &&
-               fFormat == that.fFormat;
+        return fUsage == that.fUsage && fFormat == that.fFormat && fAspect == that.fAspect;
     }
 
     bool isCompatible(const DawnTextureSpec& that) const {
         // The usages may match or the usage passed in may be a superset of the usage stored within.
-        return fFormat == that.fFormat &&
-               (fUsage & that.fUsage) == fUsage;
+        // The aspect should either match the plane aspect or should be All.
+        return fFormat == that.fFormat && (fUsage & that.fUsage) == fUsage &&
+               (fAspect == that.fAspect || fAspect == wgpu::TextureAspect::All);
     }
 
     SkString toString() const {
-        return SkStringPrintf("format=0x%08X,usage=0x%08X",
+        return SkStringPrintf("format=0x%08X,usage=0x%08X,aspect=0x%08X",
                               static_cast<unsigned int>(fFormat),
-                              static_cast<unsigned int>(fUsage));
+                              static_cast<unsigned int>(fUsage),
+                              static_cast<unsigned int>(fAspect));
     }
 
+    // `fFormat` is always single plane format or plane view format for a multiplanar wgpu::Texture.
     wgpu::TextureFormat fFormat;
     wgpu::TextureUsage fUsage;
+    wgpu::TextureAspect fAspect;
 };
 
 DawnTextureInfo DawnTextureSpecToTextureInfo(const DawnTextureSpec& dawnSpec,

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

@@ -10,6 +10,7 @@
 
 #include "include/core/SkString.h"
 #include "include/gpu/graphite/vk/VulkanGraphiteTypes.h"
+#include "include/private/gpu/vk/SkiaVulkan.h"
 
 namespace skgpu::graphite {
 
@@ -20,14 +21,16 @@ struct VulkanTextureSpec {
             , fImageTiling(VK_IMAGE_TILING_OPTIMAL)
             , fImageUsageFlags(0)
             , fSharingMode(VK_SHARING_MODE_EXCLUSIVE)
-            , fAspectMask(VK_IMAGE_ASPECT_COLOR_BIT) {}
+            , fAspectMask(VK_IMAGE_ASPECT_COLOR_BIT)
+            , fYcbcrConversionInfo({}) {}
     VulkanTextureSpec(const VulkanTextureInfo& info)
             : fFlags(info.fFlags)
             , fFormat(info.fFormat)
             , fImageTiling(info.fImageTiling)
             , fImageUsageFlags(info.fImageUsageFlags)
             , fSharingMode(info.fSharingMode)
-            , fAspectMask(info.fAspectMask) {}
+            , fAspectMask(info.fAspectMask)
+            , fYcbcrConversionInfo(info.fYcbcrConversionInfo) {}
 
     bool operator==(const VulkanTextureSpec& that) const {
         return fFlags == that.fFlags &&
@@ -35,7 +38,8 @@ struct VulkanTextureSpec {
                fImageTiling == that.fImageTiling &&
                fImageUsageFlags == that.fImageUsageFlags &&
                fSharingMode == that.fSharingMode &&
-               fAspectMask == that.fAspectMask;
+               fAspectMask == that.fAspectMask &&
+               fYcbcrConversionInfo == that.fYcbcrConversionInfo;
     }
 
     bool isCompatible(const VulkanTextureSpec& that) const {
@@ -45,7 +49,8 @@ struct VulkanTextureSpec {
                fImageTiling == that.fImageTiling &&
                fSharingMode == that.fSharingMode &&
                fAspectMask == that.fAspectMask &&
-               (fImageUsageFlags & that.fImageUsageFlags) == fImageUsageFlags;
+               (fImageUsageFlags & that.fImageUsageFlags) == fImageUsageFlags &&
+               fYcbcrConversionInfo == that.fYcbcrConversionInfo;
     }
 
     SkString toString() const {
@@ -60,13 +65,13 @@ struct VulkanTextureSpec {
                 fAspectMask);
     }
 
-    VkImageCreateFlags       fFlags;
-    VkFormat                 fFormat;
-    VkImageTiling            fImageTiling;
-    VkImageUsageFlags        fImageUsageFlags;
-    VkSharingMode            fSharingMode;
-    VkImageAspectFlags       fAspectMask;
-    // GrVkYcbcrConversionInfo  fYcbcrConversionInfo;
+    VkImageCreateFlags         fFlags;
+    VkFormat                   fFormat;
+    VkImageTiling              fImageTiling;
+    VkImageUsageFlags          fImageUsageFlags;
+    VkSharingMode              fSharingMode;
+    VkImageAspectFlags         fAspectMask;
+    VulkanYcbcrConversionInfo  fYcbcrConversionInfo;
 };
 
 VulkanTextureInfo VulkanTextureSpecToTextureInfo(const VulkanTextureSpec& vkSpec,

package/cpp/skia/include/third_party/vulkan/vulkan/vk_platform.h

@@ -2,7 +2,7 @@
 // File: vk_platform.h
 //
 /*
-** Copyright 2014-2021 The Khronos Group Inc.
+** Copyright 2014-2023 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -42,7 +42,7 @@ extern "C"
     #define VKAPI_CALL __stdcall
     #define VKAPI_PTR  VKAPI_CALL
 #elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7
-    #error "Vulkan isn't supported for the 'armeabi' NDK ABI"
+    #error "Vulkan is not supported for the 'armeabi' NDK ABI"
 #elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE)
     // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat"
     // calling convention, i.e. float parameters are passed in registers. This