@shopify/react-native-skia 1.3.12 → 1.4.0

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

@@ -8,6 +8,7 @@
 #ifndef SkTArray_DEFINED
 #define SkTArray_DEFINED
 
+#include "include/private/base/SkASAN.h"  // IWYU pragma: keep
 #include "include/private/base/SkAlignedStorage.h"
 #include "include/private/base/SkAssert.h"
 #include "include/private/base/SkAttributes.h"
@@ -63,7 +64,8 @@ public:
             this->initData(that.fSize);
             that.move(fData);
         }
-        fSize = std::exchange(that.fSize, 0);
+        this->changeSize(that.fSize);
+        that.changeSize(0);
     }
 
     /**
@@ -76,6 +78,11 @@ public:
         this->copy(array);
     }
 
+    /**
+     * 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())) {}
+
     /**
      * Creates a TArray by copying contents of an initializer list.
      */
@@ -87,13 +94,16 @@ public:
         }
         this->clear();
         this->checkRealloc(that.size(), kExactFit);
-        fSize = that.fSize;
+        this->changeSize(that.fSize);
         this->copy(that.fData);
         return *this;
     }
+
     TArray& operator=(TArray&& that) {
         if (this != &that) {
             this->clear();
+            this->unpoison();
+            that.unpoison();
             if (that.fOwnMemory) {
                 // The storage is on the heap, so move the data pointer.
                 if (fOwnMemory) {
@@ -107,18 +117,22 @@ public:
                 that.fCapacity = 0;
 
                 fOwnMemory = true;
+
+                this->changeSize(that.fSize);
             } else {
                 // The data is stored inline in that, so move it element-by-element.
                 this->checkRealloc(that.size(), kExactFit);
+                this->changeSize(that.fSize);
                 that.move(fData);
             }
-            fSize = std::exchange(that.fSize, 0);
+            that.changeSize(0);
         }
         return *this;
     }
 
     ~TArray() {
         this->destroyAll();
+        this->unpoison();
         if (fOwnMemory) {
             sk_free(fData);
         }
@@ -131,7 +145,7 @@ public:
         SkASSERT(n >= 0);
         this->clear();
         this->checkRealloc(n, kExactFit);
-        fSize = n;
+        this->changeSize(n);
         for (int i = 0; i < this->size(); ++i) {
             new (fData + i) T;
         }
@@ -144,7 +158,7 @@ public:
         SkASSERT(count >= 0);
         this->clear();
         this->checkRealloc(count, kExactFit);
-        fSize = count;
+        this->changeSize(count);
         this->copy(array);
     }
 
@@ -174,11 +188,11 @@ public:
     void removeShuffle(int n) {
         SkASSERT(n < this->size());
         int newCount = fSize - 1;
-        fSize = newCount;
         fData[n].~T();
         if (n != newCount) {
             this->move(n, newCount);
         }
+        this->changeSize(newCount);
     }
 
     // Is the array empty.
@@ -198,6 +212,7 @@ public:
      * the reference only remains valid until the next call that adds or removes elements.
      */
     T& push_back(const T& t) {
+        this->unpoison();
         T* newT;
         if (this->capacity() > fSize) SK_LIKELY {
             // Copy over the element directly.
@@ -206,7 +221,7 @@ public:
             newT = this->growAndConstructAtEnd(t);
         }
 
-        fSize += 1;
+        this->changeSize(fSize + 1);
         return *newT;
     }
 
@@ -214,6 +229,7 @@ public:
      * Adds one new T value which is copy-constructed, returning it by reference.
      */
     T& push_back(T&& t) {
+        this->unpoison();
         T* newT;
         if (this->capacity() > fSize) SK_LIKELY {
             // Move over the element directly.
@@ -222,7 +238,7 @@ public:
             newT = this->growAndConstructAtEnd(std::move(t));
         }
 
-        fSize += 1;
+        this->changeSize(fSize + 1);
         return *newT;
     }
 
@@ -230,6 +246,7 @@ public:
      *  Constructs a new T at the back of this array, returning it by reference.
      */
     template <typename... Args> T& emplace_back(Args&&... args) {
+        this->unpoison();
         T* newT;
         if (this->capacity() > fSize) SK_LIKELY {
             // Emplace the new element in directly.
@@ -238,7 +255,7 @@ public:
             newT = this->growAndConstructAtEnd(std::forward<Args>(args)...);
         }
 
-        fSize += 1;
+        this->changeSize(fSize + 1);
         return *newT;
     }
 
@@ -277,10 +294,10 @@ public:
         SkASSERT(n >= 0);
         this->checkRealloc(n, kGrowing);
         T* end = this->end();
+        this->changeSize(fSize + n);
         for (int i = 0; i < n; ++i) {
             new (end + i) T(t[i]);
         }
-        fSize += n;
         return end;
     }
 
@@ -291,10 +308,10 @@ public:
         SkASSERT(n >= 0);
         this->checkRealloc(n, kGrowing);
         T* end = this->end();
+        this->changeSize(fSize + n);
         for (int i = 0; i < n; ++i) {
             new (end + i) T(std::move(t[i]));
         }
-        fSize += n;
         return end;
     }
 
@@ -303,8 +320,8 @@ public:
      */
     void pop_back() {
         sk_collection_not_empty(this->empty());
-        --fSize;
-        fData[fSize].~T();
+        fData[fSize - 1].~T();
+        this->changeSize(fSize - 1);
     }
 
     /**
@@ -317,7 +334,7 @@ public:
         while (i-- > fSize - n) {
             (*this)[i].~T();
         }
-        fSize -= n;
+        this->changeSize(fSize - n);
     }
 
     /**
@@ -359,6 +376,25 @@ public:
         }
     }
 
+    /**
+     * Moves all elements of `that` to the end of this array, leaving `that` empty.
+     * This is a no-op if `that` is empty or equal to this array.
+     */
+    void move_back(TArray& that) {
+        if (that.empty() || &that == this) {
+            return;
+        }
+        void* dst = this->push_back_raw(that.size());
+        // After move() returns, the contents of `dst` will have either been in-place initialized
+        // using a the move constructor (per-item from `that`'s elements), or will have been
+        // mem-copied into when MEM_MOVE is true (now valid objects).
+        that.move(dst);
+        // All items in `that` have either been destroyed (when MEM_MOVE is false) or should be
+        // considered invalid (when MEM_MOVE is true). Reset fSize to 0 directly to skip any further
+        // per-item destruction.
+        that.changeSize(0);
+    }
+
     T* begin() {
         return fData;
     }
@@ -388,13 +424,14 @@ public:
 
     void clear() {
         this->destroyAll();
-        fSize = 0;
+        this->changeSize(0);
     }
 
     void shrink_to_fit() {
         if (!fOwnMemory || fSize == fCapacity) {
             return;
         }
+        this->unpoison();
         if (fSize == 0) {
             sk_free(fData);
             fData = nullptr;
@@ -405,6 +442,7 @@ public:
             if (fOwnMemory) {
                 sk_free(fData);
             }
+            // Poison is applied in `setDataFromBytes`.
             this->setDataFromBytes(allocation);
         }
     }
@@ -493,7 +531,7 @@ protected:
             this->initData(size);
         } else {
             this->setDataFromBytes(*storage);
-            fSize = size;
+            this->changeSize(size);
 
             // setDataFromBytes always sets fOwnMemory to true, but we are actually using static
             // storage here, which shouldn't ever be freed.
@@ -505,10 +543,14 @@ protected:
     // will only be used when array shrinks to fit.
     template <int InitialCapacity>
     TArray(const T* array, int size, SkAlignedSTStorage<InitialCapacity, T>* storage)
-        : TArray{storage, size}
-    {
+            : TArray{storage, size} {
         this->copy(array);
     }
+    template <int InitialCapacity>
+    TArray(SkSpan<const T> data, SkAlignedSTStorage<InitialCapacity, T>* storage)
+            : TArray{storage, static_cast<int>(data.size())} {
+        this->copy(data.begin());
+    }
 
 private:
     // Growth factors for checkRealloc.
@@ -533,9 +575,39 @@ private:
     }
 
     void setData(SkSpan<T> array) {
+        this->unpoison();
+
         fData = array.data();
         fCapacity = SkToU32(array.size());
         fOwnMemory = true;
+
+        this->poison();
+    }
+
+    void unpoison() {
+#ifdef SK_SANITIZE_ADDRESS
+        if (fData && fPoisoned) {
+            // SkDebugf("UNPOISONING %p : 0 -> %zu\n", fData, Bytes(fCapacity));
+            sk_asan_unpoison_memory_region(this->begin(), Bytes(fCapacity));
+            fPoisoned = false;
+        }
+#endif
+    }
+
+    void poison() {
+#ifdef SK_SANITIZE_ADDRESS
+        if (fData && fCapacity > fSize) {
+            // SkDebugf("  POISONING %p : %zu -> %zu\n", fData, Bytes(fSize), Bytes(fCapacity));
+            sk_asan_poison_memory_region(this->end(), Bytes(fCapacity - fSize));
+            fPoisoned = true;
+        }
+#endif
+    }
+
+    void changeSize(int n) {
+        this->unpoison();
+        fSize = n;
+        this->poison();
     }
 
     // We disable Control-Flow Integrity sanitization (go/cfi) when casting item-array buffers.
@@ -561,7 +633,7 @@ private:
 
     void initData(int count) {
         this->setDataFromBytes(Allocate(count));
-        fSize = count;
+        this->changeSize(count);
     }
 
     void destroyAll() {
@@ -617,7 +689,7 @@ private:
     void* push_back_raw(int n) {
         this->checkRealloc(n, kGrowing);
         void* ptr = fData + fSize;
-        fSize += n;
+        this->changeSize(fSize + n);
         return ptr;
     }
 
@@ -672,6 +744,9 @@ private:
     int fSize{0};
     uint32_t fOwnMemory : 1;
     uint32_t fCapacity : 31;
+#ifdef SK_SANITIZE_ADDRESS
+    bool fPoisoned = false;
+#endif
 };
 
 template <typename T, bool M> static inline void swap(TArray<T, M>& a, TArray<T, M>& b) {
@@ -679,9 +754,15 @@ template <typename T, bool M> static inline void swap(TArray<T, M>& a, TArray<T,
 }
 
 // Subclass of TArray that contains a pre-allocated memory block for the array.
-template <int N, typename T, bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>
-class STArray : private SkAlignedSTStorage<N,T>, public TArray<T, MEM_MOVE> {
-    static_assert(N > 0);
+template <int Nreq, typename T, bool MEM_MOVE = sk_is_trivially_relocatable_v<T>>
+class STArray : private SkAlignedSTStorage<SkContainerAllocator::RoundUp<T>(Nreq), T>,
+                public TArray<T, MEM_MOVE> {
+    // We round up the requested array size to the next capacity multiple.
+    // This space would likely otherwise go to waste.
+    static constexpr int N = SkContainerAllocator::RoundUp<T>(Nreq);
+    static_assert(Nreq > 0);
+    static_assert(N >= Nreq);
+
     using Storage = SkAlignedSTStorage<N,T>;
 
 public:
@@ -694,6 +775,10 @@ public:
         : Storage{}
         , TArray<T, MEM_MOVE>{array, count, this} {}
 
+    STArray(SkSpan<const T> data)
+        : Storage{}
+        , TArray<T, MEM_MOVE>{data, this} {}
+
     STArray(std::initializer_list<T> data)
         : STArray{data.begin(), SkToInt(data.size())} {}
 

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

@@ -10,7 +10,6 @@
 
 #include "include/private/base/SkDebug.h"
 
-#include <cstdint>
 #include <limits>
 #include <type_traits>
 
@@ -88,18 +87,8 @@ typename std::enable_if<(std::is_integral<S>::value || std::is_enum<S>::value) &
     (std::is_signed<Da>::value && std::is_unsigned<Sa>::value && sizeof(Da) <= sizeof(Sa)) ?
         src <= (S)std::numeric_limits<Da>::max() :
 
-#if !defined(SK_DEBUG) && !defined(__MSVC_RUNTIME_CHECKS )
-    // Correct (simple) version. This trips up MSVC's /RTCc run-time checking.
+    // This trips up MSVC's /RTCc run-time checking, which we don't support.
     (S)(D)src == src;
-#else
-    // More complex version that's safe with /RTCc. Used in all debug builds, for coverage.
-    (std::is_signed<Sa>::value) ?
-        (intmax_t)src >= (intmax_t)std::numeric_limits<Da>::min() &&
-        (intmax_t)src <= (intmax_t)std::numeric_limits<Da>::max() :
-
-    // std::is_unsigned<S> ?
-        (uintmax_t)src <= (uintmax_t)std::numeric_limits<Da>::max();
-#endif
 }
 
 #endif

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

@@ -10,7 +10,7 @@
 
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkTypes.h"
-#include "include/gpu/GrRecordingContext.h"
+#include "include/gpu/ganesh/GrRecordingContext.h"
 #include "include/private/base/SkTArray.h"
 #include "include/private/chromium/GrSurfaceCharacterization.h"
 

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

@@ -13,21 +13,10 @@
 #include "include/private/chromium/GrDeferredDisplayList.h"
 #include "include/private/chromium/GrSurfaceCharacterization.h"
 
-class GrBackendFormat;
 class GrRecordingContext;
 class GrRenderTargetProxy;
-class GrYUVABackendTextureInfo;
 class SkCanvas;
-class SkColorSpace;
-class SkImage;
-class GrPromiseImageTexture;
 class SkSurface;
-enum SkAlphaType : int;
-enum SkColorType : int;
-enum GrSurfaceOrigin : int;
-namespace skgpu {
-enum class Mipmapped : bool;
-}
 
 /*
  * This class is intended to be used as:
@@ -57,34 +46,6 @@ public:
 
     sk_sp<GrDeferredDisplayList> detach();
 
-    using PromiseImageTextureContext = void*;
-    using PromiseImageTextureFulfillProc =
-            sk_sp<GrPromiseImageTexture> (*)(PromiseImageTextureContext);
-    using PromiseImageTextureReleaseProc = void (*)(PromiseImageTextureContext);
-
-#ifndef SK_MAKE_PROMISE_TEXTURE_DISABLE_LEGACY_API
-    /** Deprecated: Use SkImages::PromiseTextureFrom instead. */
-    sk_sp<SkImage> makePromiseTexture(const GrBackendFormat& backendFormat,
-                                      int width,
-                                      int height,
-                                      skgpu::Mipmapped mipmapped,
-                                      GrSurfaceOrigin origin,
-                                      SkColorType colorType,
-                                      SkAlphaType alphaType,
-                                      sk_sp<SkColorSpace> colorSpace,
-                                      PromiseImageTextureFulfillProc textureFulfillProc,
-                                      PromiseImageTextureReleaseProc textureReleaseProc,
-                                      PromiseImageTextureContext textureContext);
-
-    /** Deprecated: Use SkImages::PromiseTextureFromYUVA instead. */
-    sk_sp<SkImage> makeYUVAPromiseTexture(const GrYUVABackendTextureInfo& yuvaBackendTextureInfo,
-                                          sk_sp<SkColorSpace> imageColorSpace,
-                                          PromiseImageTextureFulfillProc textureFulfillProc,
-                                          PromiseImageTextureReleaseProc textureReleaseProc,
-                                          PromiseImageTextureContext textureContexts[]);
-#endif // SK_MAKE_PROMISE_TEXTURE_DISABLE_LEGACY_API
-
-
 private:
     GrDeferredDisplayListRecorder(const GrDeferredDisplayListRecorder&) = delete;
     GrDeferredDisplayListRecorder& operator=(const GrDeferredDisplayListRecorder&) = delete;

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

@@ -10,7 +10,7 @@
 
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkTypes.h"
-#include "include/gpu/GrBackendSurface.h"
+#include "include/gpu/ganesh/GrBackendSurface.h"
 /**
  * This type is used to fulfill textures for PromiseImages. Once an instance is returned from a
  * PromiseImageTextureFulfillProc the GrBackendTexture it wraps must remain valid until the

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

@@ -16,9 +16,9 @@
 #include "include/core/SkSurfaceProps.h"
 #include "include/core/SkTypes.h"
 #include "include/gpu/GpuTypes.h"
-#include "include/gpu/GrBackendSurface.h"
-#include "include/gpu/GrContextThreadSafeProxy.h"
-#include "include/gpu/GrTypes.h"
+#include "include/gpu/ganesh/GrBackendSurface.h"
+#include "include/gpu/ganesh/GrContextThreadSafeProxy.h"
+#include "include/gpu/ganesh/GrTypes.h"
 #include "include/private/base/SkDebug.h"
 
 #include <cstddef>

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

@@ -24,7 +24,6 @@ class SkStrikeCache;
 class SkStrikeClientImpl;
 class SkStrikeServerImpl;
 class SkSurfaceProps;
-struct SkDeserialProcs;
 namespace sktext::gpu { class Slug; }
 
 using SkDiscardableHandleId = uint32_t;
@@ -143,9 +142,7 @@ public:
 
     // 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> deserializeSlugForTest(const void* data,
-                                                    size_t size,
-                                                    const SkDeserialProcs&) 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/Slug.h

@@ -10,7 +10,6 @@
 
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
-#include "include/core/SkSerialProcs.h"  // IWYU pragma: keep
 #include "include/private/base/SkAPI.h"
 
 #include <cstddef>
@@ -23,6 +22,7 @@ class SkReadBuffer;
 class SkStrikeClient;
 class SkTextBlob;
 class SkWriteBuffer;
+struct SkDeserialProcs;
 struct SkPoint;
 
 namespace sktext::gpu {
@@ -38,31 +38,25 @@ public:
             SkCanvas* canvas, const SkTextBlob& blob, SkPoint origin, const SkPaint& paint);
 
     // Serialize the slug.
-    sk_sp<SkData> serialize(const SkSerialProcs& procs = {}) const;
-    size_t serialize(void* buffer, size_t size, const SkSerialProcs& procs = {}) const;
+    sk_sp<SkData> serialize() const;
+    size_t serialize(void* buffer, size_t size) const;
 
     // Set the client parameter to the appropriate SkStrikeClient when typeface ID translation
     // is needed.
     static sk_sp<Slug> Deserialize(const void* data,
                                    size_t size,
-                                   const SkStrikeClient* client = nullptr,
-                                   const SkDeserialProcs& procs = {});
+                                   const SkStrikeClient* client = nullptr);
     static sk_sp<Slug> MakeFromBuffer(SkReadBuffer& buffer);
 
     // Allows clients to deserialize SkPictures that contain slug data
     static void AddDeserialProcs(SkDeserialProcs* procs, const SkStrikeClient* client = nullptr);
 
     // Draw the Slug obeying the canvas's mapping and clipping.
-    void draw(SkCanvas* canvas) const;
+    void draw(SkCanvas* canvas, const SkPaint& paint) const;
 
     virtual SkRect sourceBounds() const = 0;
     virtual SkRect sourceBoundsWithOrigin () const = 0;
 
-    // The paint passed into ConvertBlob; this paint is used instead of the paint resulting from
-    // the call to aboutToDraw because when we call draw(), the initial paint is needed to call
-    // aboutToDraw again to get the layer right.
-    virtual const SkPaint& initialPaint() const = 0;
-
     virtual void doFlatten(SkWriteBuffer&) const = 0;
 
     uint32_t uniqueID() const { return fUniqueID; }

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

@@ -9,7 +9,7 @@
 #define GrContext_Base_DEFINED
 
 #include "include/core/SkRefCnt.h"
-#include "include/gpu/GrTypes.h"
+#include "include/gpu/ganesh/GrTypes.h"
 #include "include/private/base/SkAPI.h"
 
 #include <cstdint>

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

@@ -14,7 +14,7 @@
 
 #include <dxgiformat.h>
 
-#include "include/gpu/GrTypes.h"
+#include "include/gpu/ganesh/GrTypes.h"
 
 struct ID3D12Resource;
 class GrD3DResourceState;
@@ -48,7 +48,7 @@ struct GrD3DBackendSurfaceInfo {
     GrD3DTextureResourceInfo snapTextureResourceInfo() const;
 
     bool isProtected() const;
-#if defined(GR_TEST_UTILS)
+#if defined(GPU_TEST_UTILS)
     bool operator==(const GrD3DBackendSurfaceInfo& that) const;
 #endif
 

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

@@ -9,7 +9,7 @@
 #define GrTextureGenerator_DEFINED
 
 #include "include/core/SkImageGenerator.h"
-#include "include/gpu/GrTypes.h"
+#include "include/gpu/ganesh/GrTypes.h"
 #include "include/private/base/SkAPI.h"
 
 #include <cstdint>