@shopify/react-native-skia 2.4.7 → 2.4.14

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

@@ -9,11 +9,13 @@
 #define skgpu_VulkanTypes_DEFINED
 
 #include "include/core/SkTypes.h"
+#include "include/private/base/SkTo.h"
 #include "include/private/gpu/vk/SkiaVulkan.h"
 
 #include <cstddef>
 #include <cstdint>
 #include <functional>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -23,6 +25,10 @@
 
 namespace skgpu {
 
+namespace graphite {
+class VulkanYcbcrConversion;
+}
+
 using VulkanGetProc = std::function<PFN_vkVoidFunction(
         const char*, // function name
         VkInstance,  // instance or VK_NULL_HANDLE
@@ -60,16 +66,62 @@ private:
 
 // Used to pass in the necessary information to create a VkSamplerYcbcrConversion object for an
 // VkExternalFormatANDROID.
-struct VulkanYcbcrConversionInfo {
+struct SK_API VulkanYcbcrConversionInfo {
+public:
+    // Makes an invalid VulkanYcbcrConversionInfo
+    VulkanYcbcrConversionInfo() = default;
+
+    // For external images format features here should be those returned by a call to
+    // vkAndroidHardwareBufferFormatPropertiesANDROID
+    VulkanYcbcrConversionInfo(uint64_t externalFormat,
+                              VkSamplerYcbcrModelConversion ycbcrModel,
+                              VkSamplerYcbcrRange ycbcrRange,
+                              VkChromaLocation xChromaOffset,
+                              VkChromaLocation yChromaOffset,
+                              VkFilter chromaFilter,
+                              VkBool32 forceExplicitReconstruction,
+                              VkComponentMapping components,
+                              VkFormatFeatureFlags formatFeatures)
+            : VulkanYcbcrConversionInfo(VK_FORMAT_UNDEFINED,
+                                        externalFormat,
+                                        ycbcrModel,
+                                        ycbcrRange,
+                                        xChromaOffset,
+                                        yChromaOffset,
+                                        chromaFilter,
+                                        forceExplicitReconstruction,
+                                        components,
+                                        formatFeatures) {}
+
+    VulkanYcbcrConversionInfo(VkFormat format,
+                              VkSamplerYcbcrModelConversion ycbcrModel,
+                              VkSamplerYcbcrRange ycbcrRange,
+                              VkChromaLocation xChromaOffset,
+                              VkChromaLocation yChromaOffset,
+                              VkFilter chromaFilter,
+                              VkBool32 forceExplicitReconstruction,
+                              VkComponentMapping components,
+                              VkFormatFeatureFlags formatFeatures)
+            : VulkanYcbcrConversionInfo(format,
+                                        0,
+                                        ycbcrModel,
+                                        ycbcrRange,
+                                        xChromaOffset,
+                                        yChromaOffset,
+                                        chromaFilter,
+                                        forceExplicitReconstruction,
+                                        components,
+                                        formatFeatures) {}
+
     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;
         }
 
-        // Note that we do not need to check for fFormatFeatures equality. This is because the
-        // Vulkan spec dictates that Android hardware buffers with the same external format must
-        // have the same support for key features. See
+        // Note that we do not need to check for fSamplerFilterMustMatchChromaFilter equality. This
+        // is because the Vulkan spec dictates that Android hardware buffers with the same external
+        // format must have the same support for key features. See
         // https://docs.vulkan.org/spec/latest/chapters/memory.html#_android_hardware_buffer_external_memory
         // for more details.
         return this->fFormat                      == that.fFormat                      &&
@@ -89,9 +141,70 @@ struct VulkanYcbcrConversionInfo {
 
     bool isValid() const {
         return fYcbcrModel != VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY ||
-               fExternalFormat != 0;
+               this->hasExternalFormat();
     }
 
+    VkFormat format() const { return fFormat; }
+
+    bool hasExternalFormat() const { return fExternalFormat != 0; }
+    uint64_t externalFormat() const { return fExternalFormat; }
+
+    VkSamplerYcbcrModelConversion model() const { return fYcbcrModel; }
+    VkSamplerYcbcrRange range() const { return fYcbcrRange; }
+    VkChromaLocation xChromaOffset() const { return fXChromaOffset; }
+    VkChromaLocation yChromaOffset() const { return fYChromaOffset; }
+    VkFilter chromaFilter() const { return fChromaFilter; }
+    VkBool32 forceExplicitReconstruction() const { return fForceExplicitReconstruction; }
+    VkComponentMapping components() const { return fComponents; }
+
+    bool samplerFilterMustMatchChromaFilter() const { return fSamplerFilterMustMatchChromaFilter; }
+    bool supportsLinearFilter() const { return fSupportsLinearFilter; }
+
+    // Returns a populated VkSamplerYcbcrConversionCreateInfo object based on
+    // VulkanYcbcrConversionInfo
+    void toVkSamplerYcbcrConversionCreateInfo(VkSamplerYcbcrConversionCreateInfo* outInfo,
+                                              std::optional<VkFilter>* requiredSamplerFilter) const;
+
+private:
+    VulkanYcbcrConversionInfo(VkFormat format,
+                              uint64_t externalFormat,
+                              VkSamplerYcbcrModelConversion ycbcrModel,
+                              VkSamplerYcbcrRange ycbcrRange,
+                              VkChromaLocation xChromaOffset,
+                              VkChromaLocation yChromaOffset,
+                              VkFilter chromaFilter,
+                              VkBool32 forceExplicitReconstruction,
+                              VkComponentMapping components,
+                              VkFormatFeatureFlags formatFeatures);
+
+
+    // For use internally to recreate from an ImmutableSamplerInfo. We don't have feature flags
+    // and assume we've updated all the fields as required by the feature flags previously.
+    friend class graphite::VulkanYcbcrConversion;
+
+    VulkanYcbcrConversionInfo(VkFormat format,
+                              uint64_t externalFormat,
+                              VkSamplerYcbcrModelConversion ycbcrModel,
+                              VkSamplerYcbcrRange ycbcrRange,
+                              VkChromaLocation xChromaOffset,
+                              VkChromaLocation yChromaOffset,
+                              VkFilter chromaFilter,
+                              VkBool32 forceExplicitReconstruction,
+                              VkComponentMapping components,
+                              bool mustMatchChromaFilter,
+                              bool supportsLinearFilter)
+            : fFormat(format)
+            , fExternalFormat(externalFormat)
+            , fYcbcrModel(ycbcrModel)
+            , fYcbcrRange(ycbcrRange)
+            , fXChromaOffset(xChromaOffset)
+            , fYChromaOffset(yChromaOffset)
+            , fChromaFilter(chromaFilter)
+            , fForceExplicitReconstruction(forceExplicitReconstruction)
+            , fComponents(components)
+            , fSamplerFilterMustMatchChromaFilter(mustMatchChromaFilter)
+            , fSupportsLinearFilter(supportsLinearFilter) {}
+
     // 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;
@@ -107,15 +220,17 @@ struct VulkanYcbcrConversionInfo {
     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;
-
     // This is ignored when fExternalFormat is non-zero.
     VkComponentMapping fComponents            = {VK_COMPONENT_SWIZZLE_IDENTITY,
                                                  VK_COMPONENT_SWIZZLE_IDENTITY,
                                                  VK_COMPONENT_SWIZZLE_IDENTITY,
                                                  VK_COMPONENT_SWIZZLE_IDENTITY};
+
+    // Default these values to the most restrictive. These defaults only really matter until
+    // we force all clients to go through our constructors. At that point these will be set to the
+    // correct values.
+    bool fSamplerFilterMustMatchChromaFilter = true;
+    bool fSupportsLinearFilter = false;
 };
 
 typedef void* VulkanDeviceLostContext;

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

@@ -11,9 +11,11 @@
 #include <fuchsia/fonts/cpp/fidl.h>
 
 #include "include/core/SkRefCnt.h"
+#include <memory>
 
 class SkFontMgr;
+class SkFontScanner;
 
-SK_API sk_sp<SkFontMgr> SkFontMgr_New_Fuchsia(fuchsia::fonts::ProviderSyncPtr provider);
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_Fuchsia(fuchsia::fonts::ProviderSyncPtr provider, std::unique_ptr<SkFontScanner> scanner);
 
 #endif  // SkFontMgr_fuchsia_DEFINED

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

@@ -21,7 +21,7 @@
 #include <memory>
 
 namespace SkImageGeneratorCG {
-SK_API std::unique_ptr<SkImageGenerator> MakeFromEncodedCG(sk_sp<SkData>);
+SK_API std::unique_ptr<SkImageGenerator> MakeFromEncodedCG(sk_sp<const SkData>);
 }  // namespace SkImageGeneratorCG
 
 #endif  // defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)

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

@@ -33,7 +33,7 @@ namespace SkImageGeneratorNDK {
  *  API like SkCodecImageGenerator::getScaledDimensions() to report which
  *  dimensions are supported?
  */
-SK_API std::unique_ptr<SkImageGenerator> MakeFromEncodedNDK(sk_sp<SkData>);
+SK_API std::unique_ptr<SkImageGenerator> MakeFromEncodedNDK(sk_sp<const SkData>);
 }
 
 #endif // SK_ENABLE_NDK_IMAGES

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

@@ -34,7 +34,7 @@
  * https://msdn.microsoft.com/en-us/library/windows/desktop/ff485844.aspx
  */
 namespace SkImageGeneratorWIC {
-SK_API std::unique_ptr<SkImageGenerator> MakeFromEncodedWIC(sk_sp<SkData>);
+SK_API std::unique_ptr<SkImageGenerator> MakeFromEncodedWIC(sk_sp<const SkData>);
 }
 
 #endif  // SK_BUILD_FOR_WIN

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

@@ -18,7 +18,7 @@
 SK_API sk_sp<SkTypeface> SkTypeface_Make_Fontations(std::unique_ptr<SkStreamAsset> fontData,
                                                     const SkFontArguments& args);
 
-SK_API sk_sp<SkTypeface> SkTypeface_Make_Fontations(sk_sp<SkData> fontData,
+SK_API sk_sp<SkTypeface> SkTypeface_Make_Fontations(sk_sp<const SkData> fontData,
                                                     const SkFontArguments& args);
 
 #endif

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

@@ -28,16 +28,16 @@ struct SkEncodedInfo {
 public:
     class ICCProfile {
     public:
-        static std::unique_ptr<ICCProfile> Make(sk_sp<SkData>);
+        static std::unique_ptr<ICCProfile> Make(sk_sp<const SkData>);
         static std::unique_ptr<ICCProfile> Make(const skcms_ICCProfile&);
 
         const skcms_ICCProfile* profile() const { return &fProfile; }
-        sk_sp<SkData> data() const { return fData; }
+        sk_sp<const SkData> data() const { return fData; }
     private:
-        ICCProfile(const skcms_ICCProfile&, sk_sp<SkData> = nullptr);
+        ICCProfile(const skcms_ICCProfile&, sk_sp<const SkData> = nullptr);
 
-        skcms_ICCProfile fProfile;
-        sk_sp<SkData>    fData;
+        skcms_ICCProfile     fProfile;
+        sk_sp<const SkData>  fData;
     };
 
     enum Alpha {
@@ -172,7 +172,7 @@ public:
         if (!fProfile) return nullptr;
         return fProfile->profile();
     }
-    sk_sp<SkData> profileData() const {
+    sk_sp<const SkData> profileData() const {
         if (!fProfile) return nullptr;
         return fProfile->data();
     }
@@ -213,9 +213,14 @@ public:
 
     // Explicit copy method, to avoid accidental copying.
     SkEncodedInfo copy() const {
-        return SkEncodedInfo(
-                fWidth, fHeight, fColor, fAlpha, fBitsPerComponent, fColorDepth,
-                fProfile ? std::make_unique<ICCProfile>(*fProfile) : nullptr, fHdrMetadata);
+        return SkEncodedInfo(fWidth,
+                             fHeight,
+                             fColor,
+                             fAlpha,
+                             fBitsPerComponent,
+                             fColorDepth,
+                             fProfile ? std::make_unique<const ICCProfile>(*fProfile) : nullptr,
+                             fHdrMetadata);
     }
 
     // Return number of bits of R/G/B channel
@@ -230,18 +235,22 @@ public:
     }
 
 private:
-    SkEncodedInfo(int width, int height, Color color, Alpha alpha,
-            uint8_t bitsPerComponent, uint8_t colorDepth, std::unique_ptr<ICCProfile> profile,
-            const skhdr::Metadata& hdrMetadata)
-        : fWidth(width)
-        , fHeight(height)
-        , fColor(color)
-        , fAlpha(alpha)
-        , fBitsPerComponent(bitsPerComponent)
-        , fColorDepth(colorDepth)
-        , fProfile(std::move(profile))
-        , fHdrMetadata(hdrMetadata)
-    {}
+    SkEncodedInfo(int width,
+                  int height,
+                  Color color,
+                  Alpha alpha,
+                  uint8_t bitsPerComponent,
+                  uint8_t colorDepth,
+                  std::unique_ptr<const ICCProfile> profile,
+                  const skhdr::Metadata& hdrMetadata)
+            : fWidth(width)
+            , fHeight(height)
+            , fColor(color)
+            , fAlpha(alpha)
+            , fBitsPerComponent(bitsPerComponent)
+            , fColorDepth(colorDepth)
+            , fProfile(std::move(profile))
+            , fHdrMetadata(hdrMetadata) {}
 
     static void VerifyColor(Color color, Alpha alpha, int bitsPerComponent) {
         // Avoid `-Wunused-parameter` warnings on non-debug builds.
@@ -289,14 +298,14 @@ private:
         SkASSERT(false);  // Unrecognized `color` enum value.
     }
 
-    int                         fWidth;
-    int                         fHeight;
-    Color                       fColor;
-    Alpha                       fAlpha;
-    uint8_t                     fBitsPerComponent;
-    uint8_t                     fColorDepth;
-    std::unique_ptr<ICCProfile> fProfile;
-    skhdr::Metadata             fHdrMetadata;
+    int                               fWidth;
+    int                               fHeight;
+    Color                                   fColor;
+    Alpha                             fAlpha;
+    uint8_t                           fBitsPerComponent;
+    uint8_t                           fColorDepth;
+    std::unique_ptr<const ICCProfile> fProfile;
+    skhdr::Metadata                   fHdrMetadata;
 };
 
 #endif

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

@@ -32,13 +32,14 @@ public:
      * A segment from a JPEG file. This is usually populated from a jpeg_marker_struct.
      */
     struct SK_API Segment {
-        Segment(uint8_t marker, sk_sp<SkData> data) : fMarker(marker), fData(std::move(data)) {}
+        Segment(uint8_t marker, sk_sp<const SkData> data)
+                : fMarker(marker), fData(std::move(data)) {}
 
         // The segment's marker.
         uint8_t fMarker = 0;
 
         // The segment's parameters (not including the marker and parameter length).
-        sk_sp<SkData> fData;
+        sk_sp<const SkData> fData;
     };
 
     /**
@@ -50,28 +51,28 @@ public:
     /**
      * Create metadata for the specified encoded JPEG file. This may return nullptr.
      */
-    static std::unique_ptr<SkJpegMetadataDecoder> Make(sk_sp<SkData> data);
+    static std::unique_ptr<SkJpegMetadataDecoder> Make(sk_sp<const SkData> data);
 
     /**
      * Return the Exif data attached to the image (if any) and nullptr otherwise. If |copyData| is
      * false, then the returned SkData may directly reference the data provided when this object was
      * created.
      */
-    virtual sk_sp<SkData> getExifMetadata(bool copyData) const = 0;
+    virtual sk_sp<const SkData> getExifMetadata(bool copyData) const = 0;
 
     /**
      * Return the ICC profile of the image if any, and nullptr otherwise. If |copyData| is false,
      * then the returned SkData may directly reference the data provided when this object was
      * created.
      */
-    virtual sk_sp<SkData> getICCProfileData(bool copyData) const = 0;
+    virtual sk_sp<const SkData> getICCProfileData(bool copyData) const = 0;
 
     /**
      * Return the ISO 21496-1 metadata, if any, and nullptr otherwise. If |copyData| is false,
      * then the returned SkData may directly reference the data provided when this object was
      * created.
      */
-    virtual sk_sp<SkData> getISOGainmapMetadata(bool copyData) const = 0;
+    virtual sk_sp<const SkData> getISOGainmapMetadata(bool copyData) const = 0;
 
     /**
      * Return true if there is a possibility that this image contains a gainmap image.
@@ -83,16 +84,20 @@ public:
      * gainmap image and return in |outGainmapInfo| its gainmap rendering parameters. Return true if
      * both output variables were successfully populated, otherwise return false.
      */
-    virtual bool findGainmapImage(sk_sp<SkData> baseImageData,
+    virtual std::pair<sk_sp<const SkData>, SkGainmapInfo> findGainmapImage(
+            sk_sp<const SkData>) const = 0;
+
+    // deprecated
+    virtual bool findGainmapImage(sk_sp<const SkData> baseImageData,
                                   sk_sp<SkData>& outGainmapImagedata,
                                   SkGainmapInfo& outGainmapInfo) = 0;
 
-     /**
-      * Return the first JUMBF superbox, if any, and nullptr otherwise. If |copyData| is false,
-      * then the returned SkData may directly reference the data provided when this object was
-      * created.
-      */
-    virtual sk_sp<SkData> getJUMBFMetadata(bool copyData) const = 0;
+    /**
+     * Return the first JUMBF superbox, if any, and nullptr otherwise. If |copyData| is false,
+     * then the returned SkData may directly reference the data provided when this object was
+     * created.
+     */
+    virtual sk_sp<const SkData> getJUMBFMetadata(bool copyData) const = 0;
 };
 
 #endif

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

@@ -118,7 +118,7 @@ public:
     {
         fBoundsIsDirty = true;    // this also invalidates fIsFinite
         fGenerationID = 0;        // recompute
-        fSegmentMask = segmentMask;
+        fSegmentMask = SkToU8(segmentMask);
         fType = SkPathIsAType::kGeneral;
         SkDEBUGCODE(fEditorsAttached.store(0);)
         if (mx && !mx->isIdentity()) {
@@ -330,15 +330,13 @@ public:
 
     bool operator== (const SkPathRef& ref) const;
 
-    void interpolate(const SkPathRef& ending, SkScalar weight, SkPathRef* out) const;
-
     /**
      * Gets an ID that uniquely identifies the contents of the path ref. If two path refs have the
      * same ID then they have the same verbs and points. However, two path refs may have the same
      * contents but different genIDs.
      * skbug.com/40032862 for background on why fillType is necessary (for now).
      */
-    uint32_t genID(uint8_t fillType) const;
+    uint32_t genID(SkPathFillType fillType) const;
 
     void addGenIDChangeListener(sk_sp<SkIDChangeListener>);   // Threadsafe.
     int genIDChangeListenerCount();                           // Threadsafe
@@ -389,7 +387,7 @@ private:
 
     // Return true if the computed bounds are finite.
     static bool ComputePtBounds(SkRect* bounds, const SkPathRef& ref) {
-        return bounds->setBoundsCheck({ref.points(), ref.countPoints()});
+        return bounds->setBoundsCheck(ref.pointSpan());
     }
 
     // called, if dirty, by getBounds()
@@ -541,7 +539,6 @@ private:
     mutable bool    fIsFinite;    // only meaningful if bounds are valid
 
     friend class PathRefTest_Private;
-    friend class ForceIsRRect_Private; // unit test isRRect
     friend class SkPath;
     friend class SkPathBuilder;
     friend class SkPathPriv;

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

@@ -35,7 +35,7 @@ template <typename T> static constexpr bool SkIsAlignPtr(T x) {
 /**
  *  align up to a power of 2
  */
-static inline constexpr size_t SkAlignTo(size_t x, size_t alignment) {
+template <typename T> static constexpr T SkAlignTo(T x, T alignment) {
     // The same as alignment && SkIsPow2(value), w/o a dependency cycle.
     SkASSERT(alignment && (alignment & (alignment - 1)) == 0);
     return (x + alignment - 1) & ~(alignment - 1);
@@ -44,12 +44,8 @@ static inline constexpr size_t SkAlignTo(size_t x, size_t alignment) {
 /**
  *  align up to a non power of 2
  */
-static inline constexpr size_t SkAlignNonPow2(size_t x, size_t alignment) {
-    const size_t misalignment = x % alignment;
-    if (misalignment) {
-        x += alignment - misalignment;
-    }
-    return x;
+template <typename T> static constexpr T SkAlignNonPow2(T x, T alignment) {
+    return ((x + alignment - 1) / alignment) * alignment;
 }
 
 #endif

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

@@ -24,7 +24,7 @@ public:
     // Rounds a requested capacity up towards `kCapacityMultiple` in a constexpr-friendly fashion.
     template <typename T>
     static constexpr size_t RoundUp(size_t capacity) {
-        return SkAlignTo(capacity * sizeof(T), kCapacityMultiple) / sizeof(T);
+        return SkAlignTo(capacity * sizeof(T), (size_t) kCapacityMultiple) / sizeof(T);
     }
 
 private:

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

@@ -8,6 +8,27 @@
 #ifndef SkSpan_DEFINED
 #define SkSpan_DEFINED
 
+/*
+ *  Define this to keep the bespoke SkSpan implementation, until clients are ready.
+ *  When this is not defined, SkSpan becomes just an alias for std::span
+ */
+#define SK_USE_LEGACY_SKSPAN
+
+/*
+ *  SkSpan handles single POD initialization differently from std::span
+ *  This macro allows clients to initialize a span with a single POD that will work with
+ *  either implementation of SkSpan.
+ *
+ *  When we switch to std::span entirely, callsites can remove this macro, and juse type {{a}}
+ */
+#ifdef SK_USE_LEGACY_SKSPAN
+    #define SKSPAN_INIT_ONE(elem)   {elem}
+#else
+    #define SKSPAN_INIT_ONE(elem)   {{elem}}
+#endif
+
+#ifdef SK_USE_LEGACY_SKSPAN
+
 #include "include/private/base/SkAssert.h"
 #include "include/private/base/SkDebug.h"
 #include "include/private/base/SkTo.h"
@@ -126,4 +147,12 @@ template <typename Container>
 SkSpan(Container&&) ->
         SkSpan<std::remove_pointer_t<decltype(std::data(std::declval<Container>()))>>;
 
+#else
+
+#include <span>
+
+template <typename T> using SkSpan = std::span<T>;
+
+#endif  // legacy
+
 #endif  // SkSpan_DEFINED

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

@@ -81,7 +81,7 @@ public:
     /**
      * Creates a TArray by copying contents from an SkSpan. The new array will be heap allocated.
      */
-    TArray(SkSpan<const T> data) : TArray(data.begin(), static_cast<int>(data.size())) {}
+    TArray(SkSpan<const T> data) : TArray(data.data(), static_cast<int>(data.size())) {}
 
     /**
      * Creates a TArray by copying contents of an initializer list.
@@ -154,12 +154,11 @@ public:
     /**
      * Resets to a copy of a C array and resets any reserve count.
      */
-    void reset(const T* array, int count) {
-        SkASSERT(count >= 0);
+    void reset(SkSpan<const T> src) {
         this->clear();
-        this->checkRealloc(count, kExactFit);
-        this->changeSize(count);
-        this->copy(array);
+        this->checkRealloc(src.size(), kExactFit);
+        this->changeSize(src.size());
+        this->copy(src.data());
     }
 
     /**
@@ -530,7 +529,7 @@ protected:
         if (size > InitialCapacity) {
             this->initData(size);
         } else {
-            this->setDataFromBytes(*storage);
+            this->setDataFromBytes({storage->data(), storage->size()});
             this->changeSize(size);
 
             // setDataFromBytes always sets fOwnMemory to true, but we are actually using static
@@ -549,7 +548,7 @@ protected:
     template <int InitialCapacity>
     TArray(SkSpan<const T> data, SkAlignedSTStorage<InitialCapacity, T>* storage)
             : TArray{storage, static_cast<int>(data.size())} {
-        this->copy(data.begin());
+        this->copy(data.data());
     }
 
 private:

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

@@ -176,10 +176,10 @@ public:
         fStorage.clear();
     }
 
-     // Sets the number of elements in the array.
-     // If the array does not have space for count elements, it will increase
-     // the storage allocated to some amount greater than that required.
-     // It will never shrink the storage.
+    // Sets the number of elements in the array.
+    // If the array does not have space for count elements, it will increase
+    // the storage allocated to some amount greater than that required.
+    // It will never shrink the storage.
     void resize(int count) {
         fStorage.resize(count);
     }

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

@@ -82,7 +82,7 @@ template <auto F> using SkFunctionObject =
     reference is null when the destructor is called, we do not call the
     function.
 */
-template <typename T, void (*P)(T*)> class SkAutoTCallVProc
+template <typename T, void (*P)(T*)> class [[nodiscard]] SkAutoTCallVProc
     : public std::unique_ptr<T, SkFunctionObject<P>> {
     using inherited = std::unique_ptr<T, SkFunctionObject<P>>;
 public:
@@ -141,10 +141,10 @@ public:
     size_t size_bytes() const { return sizeof(T) * fSize; }
 
     T* begin() {
-        return fData;
+        return fData.get();
     }
     const T* begin() const {
-        return fData;
+        return fData.get();
     }
 
     // It's safe to use fItemArray + fSize because if fItemArray is nullptr then adding 0 is
@@ -153,13 +153,13 @@ public:
         if (fData == nullptr) {
             SkASSERT(fSize == 0);
         }
-        return fData + fSize;
+        return this->begin() + fSize;
     }
     const T* end() const {
         if (fData == nullptr) {
             SkASSERT(fSize == 0);
         }
-        return fData + fSize;
+        return this->begin() + fSize;
     }
 
 private:

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

@@ -32,7 +32,7 @@ class SkSurface;
  */
 class SK_API GrDeferredDisplayListRecorder {
 public:
-    GrDeferredDisplayListRecorder(const GrSurfaceCharacterization&);
+    explicit GrDeferredDisplayListRecorder(const GrSurfaceCharacterization&);
     ~GrDeferredDisplayListRecorder();
 
     const GrSurfaceCharacterization& characterization() const {

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

@@ -67,7 +67,7 @@ public:
 protected:
     friend class GrBaseContextPriv; // for hidden functions
 
-    GrContext_Base(sk_sp<GrContextThreadSafeProxy>);
+    explicit GrContext_Base(sk_sp<GrContextThreadSafeProxy>);
 
     virtual bool init();