@shopify/react-native-skia 0.1.212 → 0.1.214

package/cpp/skia/include/gpu/graphite/Image.h

@@ -11,6 +11,7 @@
 #include "include/core/SkImage.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSpan.h"
+#include "include/gpu/GpuTypes.h"
 
 class SkYUVAInfo;
 class SkYUVAPixmaps;
@@ -58,8 +59,19 @@ using GraphitePromiseTextureReleaseProc = void (*)(GraphitePromiseTextureRelease
                                backend texture is linear, then the colorSpace should include
                                a description of the transfer function as
                                well (e.g., SkColorSpace::MakeSRGB()).
+    @param origin              Whether the Texture logically treats the origin as TopLeft or
+                               BottomLeft
     @return                    created SkImage, or nullptr
 */
+SK_API sk_sp<SkImage> AdoptTextureFrom(skgpu::graphite::Recorder*,
+                                       const skgpu::graphite::BackendTexture&,
+                                       SkColorType colorType,
+                                       SkAlphaType alphaType,
+                                       sk_sp<SkColorSpace> colorSpace,
+                                       skgpu::Origin origin,
+                                       TextureReleaseProc = nullptr,
+                                       ReleaseContext = nullptr);
+
 SK_API sk_sp<SkImage> AdoptTextureFrom(skgpu::graphite::Recorder*,
                                        const skgpu::graphite::BackendTexture&,
                                        SkColorType colorType,
@@ -107,6 +119,7 @@ SK_API sk_sp<SkImage> AdoptTextureFrom(skgpu::graphite::Recorder*,
     @param dimensions     width & height of promised gpu texture
     @param textureInfo    structural information for the promised gpu texture
     @param colorInfo      color type, alpha type and colorSpace information for the image
+    @param origin         Whether the Texture logically treats the origin as TopLeft or BottomLeft
     @param isVolatile     volatility of the promise image
     @param fulfill        function called to get the actual backend texture,
                           and the instance for the GraphitePromiseTextureReleaseProc
@@ -115,6 +128,17 @@ SK_API sk_sp<SkImage> AdoptTextureFrom(skgpu::graphite::Recorder*,
     @param imageContext   state passed to fulfill and imageRelease
     @return               created SkImage, or nullptr
 */
+SK_API sk_sp<SkImage> PromiseTextureFrom(skgpu::graphite::Recorder*,
+                                         SkISize dimensions,
+                                         const skgpu::graphite::TextureInfo&,
+                                         const SkColorInfo&,
+                                         skgpu::Origin origin,
+                                         skgpu::graphite::Volatile,
+                                         GraphitePromiseImageFulfillProc,
+                                         GraphitePromiseImageReleaseProc,
+                                         GraphitePromiseTextureReleaseProc,
+                                         GraphitePromiseImageContext);
+
 SK_API sk_sp<SkImage> PromiseTextureFrom(skgpu::graphite::Recorder*,
                                          SkISize dimensions,
                                          const skgpu::graphite::TextureInfo&,
@@ -271,6 +295,38 @@ SK_API sk_sp<SkImage> SubsetTextureFrom(skgpu::graphite::Recorder* recorder,
                                         const SkImage* img,
                                         const SkIRect& subset,
                                         SkImage::RequiredProperties props = {});
+
+/** Creates a filtered SkImage on the GPU. filter processes the src image, potentially changing
+    color, position, and size. subset is the bounds of src that are processed
+    by filter. clipBounds is the expected bounds of the filtered SkImage. outSubset
+    is required storage for the actual bounds of the filtered SkImage. offset is
+    required storage for translation of returned SkImage.
+
+    Returns nullptr if SkImage could not be created. If nullptr is returned, outSubset
+    and offset are undefined.
+
+    Useful for animation of SkImageFilter that varies size from frame to frame.
+    Returned SkImage is created larger than required by filter so that GPU texture
+    can be reused with different sized effects. outSubset describes the valid bounds
+    of GPU texture returned. offset translates the returned SkImage to keep subsequent
+    animation frames aligned with respect to each other.
+
+    @param recorder    the recorder in which the filtering operation is to be performed
+    @param filter      how SkImage is sampled when transformed
+    @param subset      bounds of SkImage processed by filter
+    @param clipBounds  expected bounds of filtered SkImage
+    @param outSubset   storage for returned SkImage bounds
+    @param offset      storage for returned SkImage translation
+    @return            filtered SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> MakeWithFilter(skgpu::graphite::Recorder* recorder,
+                                     sk_sp<SkImage> src,
+                                     const SkImageFilter* filter,
+                                     const SkIRect& subset,
+                                     const SkIRect& clipBounds,
+                                     SkIRect* outSubset,
+                                     SkIPoint* offset);
+
 } // namespace SkImages
 
 

package/cpp/skia/include/gpu/graphite/ImageProvider.h

@@ -33,6 +33,11 @@ class Recorder;
  * If the requirements are not met by the returned image (modulo the flexibility wrt mipmapping)
  * Graphite will drop the draw.
  *
+ * All returned images must be backed by textures that have a TopLeft origin. If Skia is used to
+ * create the texture (e.g. using makeTextureImage) then this is always guaranteed. If the client
+ * returns a texture they created themselves and wrapped in Skia, they must ensure that texture has
+ * a TopLeft origin.
+ *
  * Note: by default, Graphite will not perform any caching of images
  *
  * Threading concerns:

package/cpp/skia/include/gpu/graphite/Recorder.h

@@ -15,6 +15,7 @@
 #include "include/private/base/SingleOwner.h"
 #include "include/private/base/SkTArray.h"
 
+#include <chrono>
 #include <vector>
 
 class SkCanvas;
@@ -33,7 +34,7 @@ class TextBlobRedrawCoordinator;
 
 namespace skgpu::graphite {
 
-class AtlasManager;
+class AtlasProvider;
 class BackendTexture;
 class Caps;
 class Context;
@@ -63,6 +64,10 @@ struct SK_API RecorderOptions final {
     ~RecorderOptions();
 
     sk_sp<ImageProvider> fImageProvider;
+
+    const size_t kDefaultRecorderBudget = 256 * (1 << 20);
+    // What is the budget for GPU resources allocated and held by this Recorder.
+    size_t fGpuBudgetInBytes = kDefaultRecorderBudget;
 };
 
 class SK_API Recorder final {
@@ -120,7 +125,7 @@ public:
      * Otherwise this will delete/release the backend object that is wrapped in the BackendTexture.
      * The BackendTexture will be reset to an invalid state and should not be used again.
      */
-    void deleteBackendTexture(BackendTexture&);
+    void deleteBackendTexture(const BackendTexture&);
 
     // Adds a proc that will be moved to the Recording upon snap, subsequently attached to the
     // CommandBuffer when the Recording is added, and called when that CommandBuffer is submitted
@@ -134,14 +139,25 @@ public:
     // Recording snap, at which point it is deleted.
     SkCanvas* makeDeferredCanvas(const SkImageInfo&, const TextureInfo&);
 
+    /**
+     * Frees GPU resources created and held by the Recorder. Can be called to reduce GPU memory
+     * pressure. Any resources that are still in use (e.g. being used by work submitted to the GPU)
+     * will not be deleted by this call. If the caller wants to make sure all resources are freed,
+     * then they should first make sure to submit and wait on any outstanding work.
+     */
+    void freeGpuResources();
+
+    /**
+     * Purge GPU resources on the Recorder that haven't been used in the past 'msNotUsed'
+     * milliseconds or are otherwise marked for deletion, regardless of whether the context is under
+     * budget.
+     */
+    void performDeferredCleanup(std::chrono::milliseconds msNotUsed);
+
     // Provides access to functions that aren't part of the public API.
     RecorderPriv priv();
     const RecorderPriv priv() const;  // NOLINT(readability-const-return-type)
 
-#if GRAPHITE_TEST_UTILS
-    bool deviceIsRegistered(Device*);
-#endif
-
 private:
     friend class Context; // For ctor
     friend class Device; // For registering and deregistering Devices;
@@ -184,8 +200,9 @@ private:
     std::unique_ptr<UploadBufferManager> fUploadBufferManager;
     std::vector<Device*> fTrackedDevices;
 
-    uint32_t fRecorderID;  // Needed for MessageBox handling for text
-    std::unique_ptr<AtlasManager> fAtlasManager;
+    uint32_t fUniqueID;  // Needed for MessageBox handling for text
+    uint32_t fNextRecordingID = 1;
+    std::unique_ptr<AtlasProvider> fAtlasProvider;
     std::unique_ptr<TokenTracker> fTokenTracker;
     std::unique_ptr<sktext::gpu::StrikeCache> fStrikeCache;
     std::unique_ptr<sktext::gpu::TextBlobRedrawCoordinator> fTextBlobCache;
@@ -202,7 +219,7 @@ private:
 
     skia_private::TArray<sk_sp<RefCntedCallback>> fFinishedProcs;
 
-#if GRAPHITE_TEST_UTILS
+#if defined(GRAPHITE_TEST_UTILS)
     // For testing use only -- the Context used to create this Recorder
     Context* fContext = nullptr;
 #endif

package/cpp/skia/include/gpu/graphite/Recording.h

@@ -36,10 +36,6 @@ public:
 
     RecordingPriv priv();
 
-#if GRAPHITE_TEST_UTILS
-    bool isTargetProxyInstantiated() const;
-#endif
-
 private:
     friend class Recorder;  // for ctor and LazyProxyData
     friend class RecordingPriv;
@@ -64,7 +60,9 @@ private:
         std::size_t operator()(const sk_sp<TextureProxy>& proxy) const;
     };
 
-    Recording(std::unique_ptr<TaskGraph>,
+    Recording(uint32_t uniqueID,
+              uint32_t recorderID,
+              std::unique_ptr<TaskGraph>,
               std::unordered_set<sk_sp<TextureProxy>, ProxyHash>&& nonVolatileLazyProxies,
               std::unordered_set<sk_sp<TextureProxy>, ProxyHash>&& volatileLazyProxies,
               std::unique_ptr<LazyProxyData> targetProxyData,
@@ -73,6 +71,10 @@ private:
     bool addCommands(CommandBuffer*, ResourceProvider*);
     void addResourceRef(sk_sp<Resource>);
 
+    // Used to verify ordering
+    uint32_t fUniqueID;
+    uint32_t fRecorderID;
+
     std::unique_ptr<TaskGraph> fGraph;
     // We don't always take refs to all resources used by specific Tasks (e.g. a common buffer used
     // for uploads). Instead we'll just hold onto one ref for those Resources outside the Tasks.

package/cpp/skia/include/gpu/graphite/TextureInfo.h

@@ -23,6 +23,8 @@
 #include "include/private/gpu/graphite/VulkanGraphiteTypesPriv.h"
 #endif
 
+struct SkISize;
+
 namespace skgpu::graphite {
 
 class SK_API TextureInfo {
@@ -100,12 +102,18 @@ public:
     }
 #endif
 
+    bool isCompatible(const TextureInfo& that) const;
     SkString toString() const;
 
 private:
+    friend size_t ComputeSize(SkISize dimensions, const TextureInfo&);  // for bytesPerPixel
+
+    size_t bytesPerPixel() const;
+
 #ifdef SK_DAWN
     friend class DawnCaps;
     friend class DawnCommandBuffer;
+    friend class DawnComputePipeline;
     friend class DawnGraphicsPipeline;
     friend class DawnResourceProvider;
     friend class DawnTexture;

package/cpp/skia/include/gpu/graphite/mtl/MtlGraphiteTypes.h

@@ -19,9 +19,9 @@
 #include <TargetConditionals.h>
 
 #if TARGET_OS_SIMULATOR
-#define SK_API_AVAILABLE_CA_METAL_LAYER SK_API_AVAILABLE(macos(10.11), ios(13.0))
+#define SK_API_AVAILABLE_CA_METAL_LAYER SK_API_AVAILABLE(macos(10.11), ios(13.0), tvos(13.0))
 #else  // TARGET_OS_SIMULATOR
-#define SK_API_AVAILABLE_CA_METAL_LAYER SK_API_AVAILABLE(macos(10.11), ios(8.0))
+#define SK_API_AVAILABLE_CA_METAL_LAYER SK_API_AVAILABLE(macos(10.11), ios(8.0), tvos(9.0))
 #endif  // TARGET_OS_SIMULATOR
 
 #endif // __APPLE__

package/cpp/skia/include/gpu/mtl/GrMtlTypes.h

@@ -26,9 +26,9 @@ using GrMTLHandle = const void*;
 #include <TargetConditionals.h>
 
 #if TARGET_OS_SIMULATOR
-#define SK_API_AVAILABLE_CA_METAL_LAYER SK_API_AVAILABLE(macos(10.11), ios(13.0))
+#define SK_API_AVAILABLE_CA_METAL_LAYER SK_API_AVAILABLE(macos(10.11), ios(13.0), tvos(13.0))
 #else  // TARGET_OS_SIMULATOR
-#define SK_API_AVAILABLE_CA_METAL_LAYER SK_API_AVAILABLE(macos(10.11), ios(8.0))
+#define SK_API_AVAILABLE_CA_METAL_LAYER SK_API_AVAILABLE(macos(10.11), ios(8.0), tvos(9.0))
 #endif  // TARGET_OS_SIMULATOR
 
 /**

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

@@ -34,7 +34,10 @@ struct GrVkYcbcrConversionInfo {
     }
     bool operator!=(const GrVkYcbcrConversionInfo& that) const { return !(*this == that); }
 
-    bool isValid() const { return fYcbcrModel != VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY; }
+    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.
@@ -79,7 +82,6 @@ struct GrVkImageInfo {
     bool                     fPartOfSwapchainOrAndroidWindow = false;
 #endif
 
-#if GR_TEST_UTILS
     bool operator==(const GrVkImageInfo& that) const {
         bool equal = fImage == that.fImage && fAlloc == that.fAlloc &&
                      fImageTiling == that.fImageTiling &&
@@ -97,7 +99,6 @@ struct GrVkImageInfo {
 #endif
         return equal;
     }
-#endif
 };
 
 using GrVkGetProc = skgpu::VulkanGetProc;

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

@@ -130,7 +130,7 @@ public:
      *  The caller must assume ownership of the object, and manage its reference count directly.
      *  No call to CFRelease() will be made.
      */
-    T SK_WARN_UNUSED_RESULT release() {
+    [[nodiscard]] T release() {
         T obj = fObject;
         fObject = nil;
         return obj;

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

@@ -71,29 +71,20 @@ struct SkGainmapInfo {
     };
     BaseImageType fBaseImageType = BaseImageType::kSDR;
 
-    inline bool operator==(const SkGainmapInfo& other) {
+    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;
     }
-    inline bool operator!=(const SkGainmapInfo& other) { return !(*this == other); }
+    inline bool operator!=(const SkGainmapInfo& other) const { return !(*this == other); }
 
     // TODO(ccameron): Remove these parameters once we are certain they are not used in Android.
     enum class Type {
-        kUnknown,
-        kMultiPicture,
-        kJpegR_Linear,
-        kJpegR_HLG,
-        kJpegR_PQ,
-        kHDRGM,
+        kDefault,
     };
-    SkColor4f fLogRatioMin = {0.f, 0.f, 0.f, 1.0};
-    SkColor4f fLogRatioMax = {1.f, 1.f, 1.f, 1.0};
-    float fHdrRatioMin = 1.f;
-    float fHdrRatioMax = 50.f;
-    Type fType = Type::kUnknown;
+    Type fType = Type::kDefault;
 };
 
 #endif

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

@@ -17,30 +17,7 @@ struct SkGainmapInfo;
 class SK_API SkJpegGainmapEncoder {
 public:
     /**
-     *  Encode a JpegR image to |dst|.
-     *
-     *  The base image is specified by |base|, and |baseOptions| controls the encoding behavior for
-     *  the base image.
-     *
-     *  The gainmap image is specified by |gainmap|, and |gainmapOptions| controls the encoding
-     *  behavior for the gainmap image.
-     *
-     *  The rendering behavior of the gainmap image is provided in |gainmapInfo|. Not all gainmap
-     *  based images are compatible with JpegR. If the image is not compatible with JpegR, then
-     *  convert the gainmap to a format that is capable with JpegR. This conversion may result in
-     *  less precise quantization of the gainmap image.
-     *
-     *  Returns true on success.  Returns false on an invalid or unsupported |src|.
-     */
-    static bool EncodeJpegR(SkWStream* dst,
-                            const SkPixmap& base,
-                            const SkJpegEncoder::Options& baseOptions,
-                            const SkPixmap& gainmap,
-                            const SkJpegEncoder::Options& gainmapOptions,
-                            const SkGainmapInfo& gainmapInfo);
-
-    /**
-     *  Encode an HDRGM image to |dst|.
+     *  Encode an UltraHDR image to |dst|.
      *
      *  The base image is specified by |base|, and |baseOptions| controls the encoding behavior for
      *  the base image.

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

@@ -100,7 +100,7 @@ public:
         returns false, no strong reference could be created and the owner's
         reference is in the same state as before the call.
     */
-    bool SK_WARN_UNUSED_RESULT try_ref() const {
+    [[nodiscard]] bool try_ref() const {
         if (atomic_conditional_acquire_strong_ref() != 0) {
             // Acquire barrier (L/SL), if not provided above.
             // Prevents subsequent code from happening before the increment.

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

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkAnySubclass_DEFINED
+#define SkAnySubclass_DEFINED
+
+#include "include/private/base/SkAssert.h"
+
+#include <cstddef>
+#include <new>
+#include <type_traits>  // IWYU pragma: keep
+#include <utility>
+
+/**
+ *  Stores any subclass `T` of `Base`, where sizeof(T) <= `Size`, without using the heap.
+ *  Doesn't need advance knowledge of T, so it's particularly suited to platform or backend
+ *  implementations of a generic interface, where the set of possible subclasses is finite and
+ *  known, but can't be made available at compile-time.
+ */
+template <typename Base, size_t Size>
+class SkAnySubclass {
+public:
+    SkAnySubclass() = default;
+    ~SkAnySubclass() {
+        this->reset();
+    }
+
+    SkAnySubclass(const SkAnySubclass&) = delete;
+    SkAnySubclass& operator=(const SkAnySubclass&) = delete;
+    SkAnySubclass(SkAnySubclass&&) = delete;
+    SkAnySubclass& operator=(SkAnySubclass&&) = delete;
+
+    template <typename T, typename... Args>
+    void emplace(Args&&... args) {
+        static_assert(std::is_base_of_v<Base, T>);
+        static_assert(sizeof(T) <= Size);
+        // We're going to clean up our stored object by calling ~Base:
+        static_assert(std::has_virtual_destructor_v<Base> || std::is_trivially_destructible_v<T>);
+        SkASSERT(!fValid);
+        new (fData) T(std::forward<Args>(args)...);
+        fValid = true;
+    }
+
+    void reset() {
+        if (fValid) {
+            this->get()->~Base();
+        }
+        fValid = false;
+    }
+
+    const Base* get() const {
+        SkASSERT(fValid);
+        return std::launder(reinterpret_cast<const Base*>(fData));
+    }
+
+    Base* get() {
+        SkASSERT(fValid);
+        return std::launder(reinterpret_cast<Base*>(fData));
+    }
+
+    Base* operator->() { return this->get(); }
+    const Base* operator->() const { return this->get(); }
+
+private:
+    alignas(8) std::byte fData[Size];
+    bool fValid = false;
+};
+
+#endif  // SkAnySubclass_DEFINED

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

@@ -9,8 +9,25 @@
 #define SkAssert_DEFINED
 
 #include "include/private/base/SkAPI.h"
+#include "include/private/base/SkAttributes.h"
 #include "include/private/base/SkDebug.h" // IWYU pragma: keep
 
+#include <cstddef>
+#include <limits>
+
+#if defined(__clang__) && defined(__has_attribute)
+    #if __has_attribute(likely)
+        #define SK_LIKELY [[likely]]
+        #define SK_UNLIKELY [[unlikely]]
+    #else
+        #define SK_LIKELY
+        #define SK_UNLIKELY
+    #endif
+#else
+    #define SK_LIKELY
+    #define SK_UNLIKELY
+#endif
+
 /** Called internally if we hit an unrecoverable error.
     The platform implementation must not return, but should either throw
     an exception or otherwise exit.
@@ -43,7 +60,7 @@
     } while (false)
 #endif
 
-// SkASSERT, SkASSERTF and SkASSERT_RELEASE can be used as stand alone assertion expressions, e.g.
+// SkASSERT, SkASSERTF and SkASSERT_RELEASE can be used as standalone assertion expressions, e.g.
 //    uint32_t foo(int x) {
 //        SkASSERT(x > 4);
 //        return x - 4;
@@ -53,18 +70,32 @@
 //        return SkASSERT(x > 4),
 //               x - 4;
 //    }
+#if defined(__clang__)
+#define SkASSERT_RELEASE(cond) \
+    static_cast<void>( __builtin_expect(static_cast<bool>(cond), 1) \
+        ? static_cast<void>(0) \
+        : []{ SK_ABORT("check(%s)", #cond); }() )
+
+#define SkASSERTF_RELEASE(cond, fmt, ...)                                  \
+    static_cast<void>( __builtin_expect(static_cast<bool>(cond), 1)        \
+        ? static_cast<void>(0)                                             \
+        : [&]{ SK_ABORT("assertf(%s): " fmt, #cond, ##__VA_ARGS__); }() )
+#else
 #define SkASSERT_RELEASE(cond) \
-        static_cast<void>( (cond) ? (void)0 : []{ SK_ABORT("assert(%s)", #cond); }() )
+    static_cast<void>( (cond) ? static_cast<void>(0) : []{ SK_ABORT("check(%s)", #cond); }() )
+
+#define SkASSERTF_RELEASE(cond, fmt, ...)                                   \
+    static_cast<void>( (cond)                                               \
+        ? static_cast<void>(0)                                              \
+        : [&]{ SK_ABORT("assertf(%s): " fmt, #cond, ##__VA_ARGS__); }() )
+#endif
 
 #if defined(SK_DEBUG)
-    #define SkASSERT(cond) SkASSERT_RELEASE(cond)
-    #define SkASSERTF(cond, fmt, ...) static_cast<void>( (cond) ? (void)0 : [&]{ \
-                                          SkDebugf(fmt"\n", ##__VA_ARGS__);      \
-                                          SK_ABORT("assert(%s)", #cond);         \
-                                      }() )
-    #define SkDEBUGFAIL(message)        SK_ABORT("%s", message)
-    #define SkDEBUGFAILF(fmt, ...)      SK_ABORT(fmt, ##__VA_ARGS__)
-    #define SkAssertResult(cond)        SkASSERT(cond)
+    #define SkASSERT(cond)            SkASSERT_RELEASE(cond)
+    #define SkASSERTF(cond, fmt, ...) SkASSERTF_RELEASE(cond, fmt, ##__VA_ARGS__)
+    #define SkDEBUGFAIL(message)      SK_ABORT("%s", message)
+    #define SkDEBUGFAILF(fmt, ...)    SK_ABORT(fmt, ##__VA_ARGS__)
+    #define SkAssertResult(cond)      SkASSERT(cond)
 #else
     #define SkASSERT(cond)            static_cast<void>(0)
     #define SkASSERTF(cond, fmt, ...) static_cast<void>(0)
@@ -72,7 +103,7 @@
     #define SkDEBUGFAILF(fmt, ...)
 
     // unlike SkASSERT, this macro executes its condition in the non-debug build.
-    // The if is present so that this can be used with functions marked SK_WARN_UNUSED_RESULT.
+    // The if is present so that this can be used with functions marked [[nodiscard]].
     #define SkAssertResult(cond)         if (cond) {} do {} while(false)
 #endif
 
@@ -89,4 +120,67 @@
 #  endif
 #endif
 
-#endif
+[[noreturn]] SK_API inline void sk_print_index_out_of_bounds(size_t i, size_t size) {
+    SK_ABORT("Index (%zu) out of bounds for size %zu.\n", i, size);
+}
+
+template <typename T> SK_API inline T sk_collection_check_bounds(T i, T size) {
+    if (0 <= i && i < size) SK_LIKELY {
+        return i;
+    }
+
+    SK_UNLIKELY {
+        #if defined(SK_DEBUG)
+            sk_print_index_out_of_bounds(static_cast<size_t>(i), static_cast<size_t>(size));
+        #else
+            SkUNREACHABLE;
+        #endif
+    }
+}
+
+[[noreturn]] SK_API inline void sk_print_length_too_big(size_t i, size_t size) {
+    SK_ABORT("Length (%zu) is too big for size %zu.\n", i, size);
+}
+
+template <typename T> SK_API inline T sk_collection_check_length(T i, T size) {
+    if (0 <= i && i <= size) SK_LIKELY {
+        return i;
+    }
+
+    SK_UNLIKELY {
+        #if defined(SK_DEBUG)
+            sk_print_length_too_big(static_cast<size_t>(i), static_cast<size_t>(size));
+        #else
+            SkUNREACHABLE;
+        #endif
+    }
+}
+
+SK_API inline void sk_collection_not_empty(bool empty) {
+    if (empty) SK_UNLIKELY {
+        #if defined(SK_DEBUG)
+            SK_ABORT("Collection is empty.\n");
+        #else
+            SkUNREACHABLE;
+        #endif
+    }
+}
+
+[[noreturn]] SK_API inline void sk_print_size_too_big(size_t size, size_t maxSize) {
+    SK_ABORT("Size (%zu) can't be represented in bytes. Max size is %zu.\n", size, maxSize);
+}
+
+template <typename T>
+SK_ALWAYS_INLINE size_t check_size_bytes_too_big(size_t size) {
+    const size_t kMaxSize = std::numeric_limits<size_t>::max() / sizeof(T);
+    if (size > kMaxSize) {
+        #if defined(SK_DEBUG)
+            sk_print_size_too_big(size, kMaxSize);
+        #else
+            SkUNREACHABLE;
+        #endif
+    }
+    return size;
+}
+
+#endif  // SkAssert_DEFINED

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

@@ -17,18 +17,6 @@
 #  define SK_ATTRIBUTE(attr)
 #endif
 
-#if !defined(SK_UNUSED)
-#  if !defined(__clang__) && defined(_MSC_VER)
-#    define SK_UNUSED __pragma(warning(suppress:4189))
-#  else
-#    define SK_UNUSED SK_ATTRIBUTE(unused)
-#  endif
-#endif
-
-#if !defined(SK_WARN_UNUSED_RESULT)
-    #define SK_WARN_UNUSED_RESULT SK_ATTRIBUTE(warn_unused_result)
-#endif
-
 /**
  * If your judgment is better than the compiler's (i.e. you've profiled it),
  * you can use SK_ALWAYS_INLINE to force inlining. E.g.

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

@@ -36,9 +36,6 @@
     #if !defined(SK_RESTRICT)
         #define SK_RESTRICT __restrict
     #endif
-    #if !defined(SK_WARN_UNUSED_RESULT)
-        #define SK_WARN_UNUSED_RESULT
-    #endif
 #endif
 
 #if !defined(SK_RESTRICT)