@shopify/react-native-skia 0.1.234 → 0.1.237

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

@@ -54,6 +54,50 @@ private:
     bool fUsesSystemHeap = false;
 };
 
+// Used to pass in the necessary information to create a VkSamplerYcbcrConversion object for an
+// VkExternalFormatANDROID.
+struct VulkanYcbcrConversionInfo {
+    bool operator==(const VulkanYcbcrConversionInfo& that) const {
+        // Invalid objects are not required to have all other fields initialized or matching.
+        if (!this->isValid() && !that.isValid()) {
+            return true;
+        }
+        return this->fFormat == that.fFormat &&
+               this->fExternalFormat == that.fExternalFormat &&
+               this->fYcbcrModel == that.fYcbcrModel &&
+               this->fYcbcrRange == that.fYcbcrRange &&
+               this->fXChromaOffset == that.fXChromaOffset &&
+               this->fYChromaOffset == that.fYChromaOffset &&
+               this->fChromaFilter == that.fChromaFilter &&
+               this->fForceExplicitReconstruction == that.fForceExplicitReconstruction;
+    }
+    bool operator!=(const VulkanYcbcrConversionInfo& that) const { return !(*this == that); }
+
+    bool isValid() const {
+        return fYcbcrModel != VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY ||
+               fExternalFormat != 0;
+    }
+
+    // Format of the source image. Must be set to VK_FORMAT_UNDEFINED for external images or
+    // a valid image format otherwise.
+    VkFormat fFormat = VK_FORMAT_UNDEFINED;
+
+    // The external format. Must be non-zero for external images, zero otherwise.
+    // Should be compatible to be used in a VkExternalFormatANDROID struct.
+    uint64_t fExternalFormat = 0;
+
+    VkSamplerYcbcrModelConversion fYcbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
+    VkSamplerYcbcrRange fYcbcrRange           = VK_SAMPLER_YCBCR_RANGE_ITU_FULL;
+    VkChromaLocation fXChromaOffset           = VK_CHROMA_LOCATION_COSITED_EVEN;
+    VkChromaLocation fYChromaOffset           = VK_CHROMA_LOCATION_COSITED_EVEN;
+    VkFilter fChromaFilter                    = VK_FILTER_NEAREST;
+    VkBool32 fForceExplicitReconstruction     = false;
+
+    // For external images format features here should be those returned by a call to
+    // vkAndroidHardwareBufferFormatPropertiesANDROID
+    VkFormatFeatureFlags fFormatFeatures = 0;
+};
+
 } // namespace skgpu
 
 #endif // skgpu_VulkanTypes_DEFINED

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

@@ -95,13 +95,10 @@ public:
      *  Return an SkTypeface for the given FontIdentity.
      *
      *  The default implementation simply returns a new typeface built using data obtained from
-     *  openStream(), but derived classes may implement more complex caching schemes.
+     *  openStream() using the provided SkFontMgr, but derived classes may implement more
+     *  complex caching schemes.
      */
-    virtual sk_sp<SkTypeface> makeTypeface(const FontIdentity& identity) {
-        return SkTypeface::MakeFromStream(std::unique_ptr<SkStreamAsset>(this->openStream(identity)),
-                                          identity.fTTCIndex);
-
-    }
+    virtual sk_sp<SkTypeface> makeTypeface(const FontIdentity& identity, sk_sp<SkFontMgr> mgr);
 
     /**
      *  Return a singleton instance of a direct subclass that calls into

package/cpp/skia/include/private/SkEncodedInfo.h

@@ -29,6 +29,7 @@ public:
         static std::unique_ptr<ICCProfile> Make(const skcms_ICCProfile&);
 
         const skcms_ICCProfile* profile() const { return &fProfile; }
+        sk_sp<SkData> data() const { return fData; }
     private:
         ICCProfile(const skcms_ICCProfile&, sk_sp<SkData> = nullptr);
 
@@ -197,6 +198,10 @@ public:
         if (!fProfile) return nullptr;
         return fProfile->profile();
     }
+    sk_sp<SkData> profileData() const {
+        if (!fProfile) return nullptr;
+        return fProfile->data();
+    }
 
     uint8_t bitsPerComponent() const { return fBitsPerComponent; }
 

package/cpp/skia/include/private/SkExif.h

@@ -0,0 +1,102 @@
+/*
+ * 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 SkExif_DEFINED
+#define SkExif_DEFINED
+
+#include "include/codec/SkEncodedOrigin.h"
+#include "include/core/SkData.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+#include <cstdint>
+
+class SK_API SkExifMetadata {
+public:
+    /*
+     * Parse the metadata specified in |data|.
+     */
+    SkExifMetadata(const sk_sp<SkData> data);
+
+    /*
+     * If the image encoded origin is specified, populate |out| and return true. Otherwise return
+     * false.
+     */
+    bool getOrigin(SkEncodedOrigin* out) const {
+        if (fOriginPresent && out) *out = fOriginValue;
+        return fOriginPresent;
+    }
+
+    /*
+     * If the HDR headroom is specified, populate |out| and return true. Otherwise return false.
+     */
+    bool getHdrHeadroom(float* out) const {
+        if (fHdrHeadroomPresent && out) *out = fHdrHeadroomValue;
+        return fHdrHeadroomPresent;
+    }
+
+    /*
+     * If resolution unit, x, or y is specified, populate |out| and return true. Otherwise return
+     * false.
+     */
+    bool getResolutionUnit(uint16_t* out) const {
+        if (fResolutionUnitPresent && out) *out = fResolutionUnitValue;
+        return fResolutionUnitPresent;
+    }
+    bool getXResolution(float* out) const {
+        if (fXResolutionPresent && out) *out = fXResolutionValue;
+        return fXResolutionPresent;
+    }
+    bool getYResolution(float* out) const {
+        if (fYResolutionPresent && out) *out = fYResolutionValue;
+        return fYResolutionPresent;
+    }
+
+    /*
+     * If pixel dimension x or y is specified, populate |out| and return true. Otherwise return
+     * false.
+     */
+    bool getPixelXDimension(uint32_t* out) const {
+        if (fPixelXDimensionPresent && out) *out = fPixelXDimensionValue;
+        return fPixelXDimensionPresent;
+    }
+    bool getPixelYDimension(uint32_t* out) const {
+        if (fPixelYDimensionPresent && out) *out = fPixelYDimensionValue;
+        return fPixelYDimensionPresent;
+    }
+
+private:
+    // Helper functions and constants for parsing the data.
+    void parseIfd(uint32_t ifdOffset, bool littleEndian, bool isRoot);
+
+    // The input data.
+    const sk_sp<SkData> fData;
+
+    // The origin property.
+    bool fOriginPresent = false;
+    SkEncodedOrigin fOriginValue = kTopLeft_SkEncodedOrigin;
+
+    // The HDR headroom property.
+    bool fHdrHeadroomPresent = false;
+    float fHdrHeadroomValue = 1.f;
+
+    // Resolution.
+    bool fResolutionUnitPresent = false;
+    uint16_t fResolutionUnitValue = 0;
+    bool fXResolutionPresent = false;
+    float fXResolutionValue = 0;
+    bool fYResolutionPresent = false;
+    float fYResolutionValue = 0;
+
+    // Size in pixels.
+    bool fPixelXDimensionPresent = false;
+    uint32_t fPixelXDimensionValue = 0;
+    bool fPixelYDimensionPresent = false;
+    uint32_t fPixelYDimensionValue = 0;
+};
+
+#endif

package/cpp/skia/include/private/SkGainmapInfo.h

@@ -9,6 +9,7 @@
 #define SkGainmapInfo_DEFINED
 
 #include "include/core/SkColor.h"
+#include "include/core/SkColorSpace.h"
 
 /**
  *  Gainmap rendering parameters. Suppose our display has HDR to SDR ratio of H and we wish to
@@ -71,12 +72,21 @@ struct SkGainmapInfo {
     };
     BaseImageType fBaseImageType = BaseImageType::kSDR;
 
+    /**
+     * If specified, color space to apply the gainmap in, otherwise the base image's color space
+     * is used. Only the color primaries are used, the transfer function is irrelevant.
+     */
+    sk_sp<SkColorSpace> fGainmapMathColorSpace = nullptr;
+
     inline bool operator==(const SkGainmapInfo& other) const {
         return fGainmapRatioMin == other.fGainmapRatioMin &&
                fGainmapRatioMax == other.fGainmapRatioMax && fGainmapGamma == other.fGainmapGamma &&
                fEpsilonSdr == other.fEpsilonSdr && fEpsilonHdr == other.fEpsilonHdr &&
                fDisplayRatioSdr == other.fDisplayRatioSdr &&
-               fDisplayRatioHdr == other.fDisplayRatioHdr && fBaseImageType == other.fBaseImageType;
+               fDisplayRatioHdr == other.fDisplayRatioHdr &&
+               fBaseImageType == other.fBaseImageType &&
+               SkColorSpace::Equals(fGainmapMathColorSpace.get(),
+                                    other.fGainmapMathColorSpace.get());
     }
     inline bool operator!=(const SkGainmapInfo& other) const { return !(*this == other); }
 

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

@@ -28,6 +28,22 @@
     #define SK_UNLIKELY
 #endif
 
+// c++23 will give us [[assume]] -- until then we're stuck with various other options:
+#if defined(__clang__)
+    #define SK_ASSUME(cond) __builtin_assume(cond)
+#elif defined(__GNUC__)
+    #if __GNUC__ >= 13
+        #define SK_ASSUME(cond) __attribute__((assume(cond)))
+    #else
+        // NOTE: This implementation could actually evaluate `cond`, which is not desirable.
+        #define SK_ASSUME(cond) ((cond) ? (void)0 : __builtin_unreachable())
+    #endif
+#elif defined(_MSC_VER)
+    #define SK_ASSUME(cond) __assume(cond)
+#else
+    #define SK_ASSUME(cond) ((void)0)
+#endif
+
 /** Called internally if we hit an unrecoverable error.
     The platform implementation must not return, but should either throw
     an exception or otherwise exit.

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

@@ -42,13 +42,8 @@ public:
     const void* front() const { return fFront; }
     const void* back() const  { return fBack; }
 
-    void* front() {
-        return (void*)((const SkDeque*)this)->front();
-    }
-
-    void* back() {
-        return (void*)((const SkDeque*)this)->back();
-    }
+    void* front() { return fFront; }
+    void* back() { return fBack; }
 
     /**
      * push_front and push_back return a pointer to the memory space

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

@@ -26,7 +26,7 @@
     // This is achieved in Skia by having a nested WORKSPACE in include/config and a cc_library
     // defined in that folder. As a result, we do not try to include SkUserConfig.h from the
     // top of Skia because Bazel sandboxing will move it to a different location.
-    #include "SkUserConfig.h"
+    #include "SkUserConfig.h"  // NO_G3_REWRITE
 #else
     #include "include/config/SkUserConfig.h"
 #endif

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());
 }