@shopify/react-native-skia 0.1.158 → 0.1.160

package/cpp/skia/include/core/SkImageGenerator.h

@@ -12,6 +12,7 @@
 #include "include/core/SkColor.h"
 #include "include/core/SkImage.h"
 #include "include/core/SkImageInfo.h"
+#include "include/core/SkSurfaceProps.h"
 #include "include/core/SkYUVAPixmaps.h"
 
 #include <optional>
@@ -27,6 +28,13 @@ class SkPicture;
 
 enum class GrImageTexGenPolicy : int;
 
+#if SK_GRAPHITE_ENABLED
+namespace skgpu::graphite {
+enum class Mipmapped : bool;
+class Recorder;
+}
+#endif
+
 class SK_API SkImageGenerator {
 public:
     /**
@@ -118,25 +126,13 @@ public:
      *  If the generator can natively/efficiently return its pixels as a GPU image (backed by a
      *  texture) this will return that image. If not, this will return NULL.
      *
-     *  This routine also supports retrieving only a subset of the pixels. That subset is specified
-     *  by the following rectangle:
-     *
-     *      subset = SkIRect::MakeXYWH(origin.x(), origin.y(), info.width(), info.height())
-     *
-     *  If subset is not contained inside the generator's bounds, this returns false.
-     *
-     *      whole = SkIRect::MakeWH(getInfo().width(), getInfo().height())
-     *      if (!whole.contains(subset)) {
-     *          return false;
-     *      }
-     *
      *  Regarding the GrRecordingContext parameter:
      *
      *  It must be non-NULL. The generator should only succeed if:
      *  - its internal context is the same
      *  - it can somehow convert its texture into one that is valid for the provided context.
      *
-     *  If the willNeedMipMaps flag is true, the generator should try to create a TextureProxy that
+     *  If the mipmapped parameter is kYes, the generator should try to create a TextureProxy that
      *  at least has the mip levels allocated and the base layer filled in. If this is not possible,
      *  the generator is allowed to return a non mipped proxy, but this will have some additional
      *  overhead in later allocating mips and copying of the base layer.
@@ -145,9 +141,16 @@ public:
      *  status) or whether this may (but is not required to) return a pre-existing texture that is
      *  retained by the generator (kDraw).
      */
-    GrSurfaceProxyView generateTexture(GrRecordingContext*, const SkImageInfo& info,
-                                       const SkIPoint& origin, GrMipmapped, GrImageTexGenPolicy);
+    GrSurfaceProxyView generateTexture(GrRecordingContext*,
+                                       const SkImageInfo& info,
+                                       GrMipmapped mipmapped,
+                                       GrImageTexGenPolicy);
+#endif
 
+#if SK_GRAPHITE_ENABLED
+    sk_sp<SkImage> makeTextureImage(skgpu::graphite::Recorder*,
+                                    const SkImageInfo&,
+                                    skgpu::graphite::Mipmapped);
 #endif
 
     /**
@@ -169,7 +172,8 @@ public:
     static std::unique_ptr<SkImageGenerator> MakeFromPicture(const SkISize&, sk_sp<SkPicture>,
                                                              const SkMatrix*, const SkPaint*,
                                                              SkImage::BitDepth,
-                                                             sk_sp<SkColorSpace>);
+                                                             sk_sp<SkColorSpace>,
+                                                             SkSurfaceProps props = {});
 
 protected:
     static constexpr int kNeedNewImageUniqueID = 0;
@@ -186,7 +190,7 @@ protected:
 #if SK_SUPPORT_GPU
     // returns nullptr
     virtual GrSurfaceProxyView onGenerateTexture(GrRecordingContext*, const SkImageInfo&,
-                                                 const SkIPoint&, GrMipmapped, GrImageTexGenPolicy);
+                                                 GrMipmapped, GrImageTexGenPolicy);
 
     // Most internal SkImageGenerators produce textures and views that use kTopLeft_GrSurfaceOrigin.
     // If the generator may produce textures with different origins (e.g.
@@ -195,6 +199,12 @@ protected:
     virtual GrSurfaceOrigin origin() const { return kTopLeft_GrSurfaceOrigin; }
 #endif
 
+#if SK_GRAPHITE_ENABLED
+    virtual sk_sp<SkImage> onMakeTextureImage(skgpu::graphite::Recorder*,
+                                              const SkImageInfo&,
+                                              skgpu::graphite::Mipmapped);
+#endif
+
 private:
     const SkImageInfo fInfo;
     const uint32_t fUniqueID;

package/cpp/skia/include/core/SkM44.h

@@ -30,6 +30,7 @@ struct SK_API SkV2 {
     friend SkV2 operator*(SkV2 v, SkScalar s) { return {v.x*s, v.y*s}; }
     friend SkV2 operator*(SkScalar s, SkV2 v) { return {v.x*s, v.y*s}; }
     friend SkV2 operator/(SkV2 v, SkScalar s) { return {v.x/s, v.y/s}; }
+    friend SkV2 operator/(SkScalar s, SkV2 v) { return {s/v.x, s/v.y}; }
 
     void operator+=(SkV2 v) { *this = *this + v; }
     void operator-=(SkV2 v) { *this = *this - v; }

package/cpp/skia/include/core/SkMesh.h

@@ -16,6 +16,7 @@
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSpan.h"
 #include "include/core/SkString.h"
+#include "include/effects/SkRuntimeEffect.h"
 
 #include <memory>
 #include <vector>
@@ -44,6 +45,10 @@ namespace SkSL { struct Program; }
  * return type is void then the interpolated position from vertex shader return is used as the local
  * coordinate. If the color variant is used it will be blended with SkShader (or SkPaint color in
  * absence of a shader) using the SkBlender provided to the SkCanvas draw call.
+ *
+ * The vertex and fragment programs may both contain uniforms. Uniforms with the same name are
+ * assumed to be shared between stages. It is an error to specify uniforms in the vertex and
+ * fragment program with the same name but different types, dimensionality, or layouts.
  */
 class SkMeshSpecification : public SkNVRefCnt<SkMeshSpecification> {
 public:
@@ -86,6 +91,8 @@ public:
         SkString name;
     };
 
+    using Uniform = SkRuntimeEffect::Uniform;
+
     ~SkMeshSpecification();
 
     struct Result {
@@ -134,7 +141,29 @@ public:
                        sk_sp<SkColorSpace>     cs,
                        SkAlphaType             at);
 
-    SkSpan<const Attribute> attributes() const { return SkMakeSpan(fAttributes); }
+    SkSpan<const Attribute> attributes() const { return SkSpan(fAttributes); }
+
+    /**
+     * Combined size of all 'uniform' variables. When creating a SkMesh with this specification
+     * provide an SkData of this size, containing values for all of those variables. Use uniforms()
+     * to get the offset of each uniform within the SkData.
+     */
+    size_t uniformSize() const;
+
+    /**
+     * Provides info about individual uniforms including the offset into an SkData where each
+     * uniform value should be placed.
+     */
+    SkSpan<const Uniform> uniforms() const { return SkSpan(fUniforms); }
+
+    /** Returns pointer to the named uniform variable's description, or nullptr if not found. */
+    const Uniform* findUniform(std::string_view name) const;
+
+    /** Returns pointer to the named attribute, or nullptr if not found. */
+    const Attribute* findAttribute(std::string_view name) const;
+
+    /** Returns pointer to the named varying, or nullptr if not found. */
+    const Varying* findVarying(std::string_view name) const;
 
     size_t stride() const { return fStride; }
 
@@ -158,8 +187,9 @@ private:
     SkMeshSpecification(SkSpan<const Attribute>,
                         size_t,
                         SkSpan<const Varying>,
-                        std::unique_ptr<SkSL::Program>,
-                        std::unique_ptr<SkSL::Program>,
+                        std::vector<Uniform> uniforms,
+                        std::unique_ptr<const SkSL::Program>,
+                        std::unique_ptr<const SkSL::Program>,
                         ColorType,
                         bool hasLocalCoords,
                         sk_sp<SkColorSpace>,
@@ -171,16 +201,17 @@ private:
     SkMeshSpecification& operator=(const SkMeshSpecification&) = delete;
     SkMeshSpecification& operator=(SkMeshSpecification&&) = delete;
 
-    const std::vector<Attribute>   fAttributes;
-    const std::vector<Varying>     fVaryings;
-    std::unique_ptr<SkSL::Program> fVS;
-    std::unique_ptr<SkSL::Program> fFS;
-    size_t                         fStride;
-    uint32_t                       fHash;
-    ColorType                      fColorType;
-    bool                           fHasLocalCoords;
-    sk_sp<SkColorSpace>            fColorSpace;
-    SkAlphaType                    fAlphaType;
+    const std::vector<Attribute>               fAttributes;
+    const std::vector<Varying>                 fVaryings;
+    const std::vector<Uniform>                 fUniforms;
+    const std::unique_ptr<const SkSL::Program> fVS;
+    const std::unique_ptr<const SkSL::Program> fFS;
+    const size_t                               fStride;
+          uint32_t                             fHash;
+    const ColorType                            fColorType;
+    const bool                                 fHasLocalCoords;
+    const sk_sp<SkColorSpace>                  fColorSpace;
+    const SkAlphaType                          fAlphaType;
 };
 
 /**
@@ -199,11 +230,46 @@ private:
  *
  * If Make() is used the implicit index sequence is 0, 1, 2, 3, ... and vertexCount must be at least
  * 3.
+ *
+ * Both Make() and MakeIndexed() take a SkData with the uniform values. See
+ * SkMeshSpecification::uniformSize() and SkMeshSpecification::uniforms() for sizing and packing
+ * uniforms into the SkData.
  */
 class SkMesh {
 public:
-    class IndexBuffer  : public SkRefCnt {};
-    class VertexBuffer : public SkRefCnt {};
+    class IndexBuffer  : public SkRefCnt {
+    public:
+        virtual size_t size() const = 0;
+
+        /**
+         * Modifies the data in the IndexBuffer by copying size bytes from data into the buffer
+         * at offset. Fails if offset + size > this->size() or if either offset or size is not
+         * aligned to 4 bytes. The GrDirectContext* must match that used to create the buffer. We
+         * take it as a parameter to emphasize that the context must be used to update the data and
+         * thus the context must be valid for the current thread.
+         */
+        bool update(GrDirectContext*, const void* data, size_t offset, size_t size);
+
+    private:
+        virtual bool onUpdate(GrDirectContext*, const void* data, size_t offset, size_t size) = 0;
+    };
+
+    class VertexBuffer : public SkRefCnt {
+    public:
+        virtual size_t size() const = 0;
+
+        /**
+         * Modifies the data in the IndexBuffer by copying size bytes from data into the buffer
+         * at offset. Fails if offset + size > this->size() or if either offset or size is not
+         * aligned to 4 bytes. The GrDirectContext* must match that used to create the buffer. We
+         * take it as a parameter to emphasize that the context must be used to update the data and
+         * thus the context must be valid for the current thread.
+         */
+        bool update(GrDirectContext*, const void* data, size_t offset, size_t size);
+
+    private:
+        virtual bool onUpdate(GrDirectContext*, const void* data, size_t offset, size_t size) = 0;
+    };
 
     SkMesh();
     ~SkMesh();
@@ -215,29 +281,39 @@ public:
     SkMesh& operator=(SkMesh&&);
 
     /**
-     * Makes an index buffer to be used with SkMeshes. The SkData is used to determine the
-     * size and contents of the buffer. The buffer may be CPU- or GPU-backed depending on whether
-     * GrDirectContext* is nullptr.
+     * Makes an index buffer to be used with SkMeshes. The buffer may be CPU- or GPU-backed
+     * depending on whether GrDirectContext* is nullptr.
      *
-     * @param  GrDirectContext*   If nullptr a CPU-backed object is returned that owns the SkData.
-     *                            Otherwise, the data is uploaded to the GPU and a GPU-backed buffer
-     *                            is returned. It may only be used to draw into SkSurfaces that
-     *                            are backed by the passed GrDirectContext.
-     * @param  sk_sp<SkData>      required. The data used to populate the buffer.
+     * @param  GrDirectContext*  If nullptr a CPU-backed object is returned. Otherwise, the data is
+     *                           uploaded to the GPU and a GPU-backed buffer is returned. It may
+     *                           only be used to draw into SkSurfaces that are backed by the passed
+     *                           GrDirectContext.
+     * @param  data              The data used to populate the buffer, or nullptr to create a zero-
+     *                           initialized buffer.
+     * @param  size              Both the size of the data in 'data' and the size of the resulting
+     *                           buffer.
      */
+    static sk_sp<IndexBuffer> MakeIndexBuffer(GrDirectContext*, const void* data, size_t size);
+
+    /** Deprecated in favor of const void* and size_t version above. */
     static sk_sp<IndexBuffer> MakeIndexBuffer(GrDirectContext*, sk_sp<const SkData>);
 
     /**
-     * Makes a vertex buffer to be used with SkMeshes. The SkData is used to determine the
-     * size and contents of the buffer.The buffer may be CPU- or GPU-backed depending on whether
-     * GrDirectContext* is nullptr.
+     * Makes a vertex buffer to be used with SkMeshes. The buffer may be CPU- or GPU-backed
+     * depending on whether GrDirectContext* is nullptr.
      *
-     * @param  GrDirectContext*   If nullptr a CPU-backed object is returned that owns the SkData.
-     *                            Otherwise, the data is uploaded to the GPU and a GPU-backed buffer
-     *                            is returned. It may only be used to draw into SkSurfaces that
-     *                            are backed by the passed GrDirectContext.
-     * @param  sk_sp<SkData>      required. The data used to populate the buffer.
+     * @param  GrDirectContext*  If nullptr a CPU-backed object is returned. Otherwise, the data is
+     *                           uploaded to the GPU and a GPU-backed buffer is returned. It may
+     *                           only be used to draw into SkSurfaces that are backed by the passed
+     *                           GrDirectContext.
+     * @param  data              The data used to populate the buffer, or nullptr to create a zero-
+     *                           initialized buffer.
+     * @param  size              Both the size of the data in 'data' and the size of the resulting
+     *                           buffer.
      */
+    static sk_sp<VertexBuffer> MakeVertexBuffer(GrDirectContext*, const void*, size_t size);
+
+    /** Deprecated in favor of const void* and size_t version above. */
     static sk_sp<VertexBuffer> MakeVertexBuffer(GrDirectContext*, sk_sp<const SkData>);
 
     enum class Mode { kTriangles, kTriangleStrip };
@@ -247,6 +323,7 @@ public:
                        sk_sp<VertexBuffer>,
                        size_t vertexCount,
                        size_t vertexOffset,
+                       sk_sp<const SkData> uniforms,
                        const SkRect& bounds);
 
     static SkMesh MakeIndexed(sk_sp<SkMeshSpecification>,
@@ -257,22 +334,29 @@ public:
                               sk_sp<IndexBuffer>,
                               size_t indexCount,
                               size_t indexOffset,
+                              sk_sp<const SkData> uniforms,
                               const SkRect& bounds);
 
-    sk_sp<SkMeshSpecification> spec() const { return fSpec; }
+    sk_sp<SkMeshSpecification> refSpec() const { return fSpec; }
+    SkMeshSpecification* spec() const { return fSpec.get(); }
 
     Mode mode() const { return fMode; }
 
-    sk_sp<VertexBuffer> vertexBuffer() const { return fVB; }
+    sk_sp<VertexBuffer> refVertexBuffer() const { return fVB; }
+    VertexBuffer* vertexBuffer() const { return fVB.get(); }
 
     size_t vertexOffset() const { return fVOffset; }
     size_t vertexCount()  const { return fVCount;  }
 
-    sk_sp<IndexBuffer> indexBuffer() const { return fIB; }
+    sk_sp<IndexBuffer> refIndexBuffer() const { return fIB; }
+    IndexBuffer* indexBuffer() const { return fIB.get(); }
 
     size_t indexOffset() const { return fIOffset; }
     size_t indexCount()  const { return fICount;  }
 
+    sk_sp<const SkData> refUniforms() const { return fUniforms; }
+    const SkData* uniforms() const { return fUniforms.get(); }
+
     SkRect bounds() const { return fBounds; }
 
     bool isValid() const;
@@ -287,6 +371,8 @@ private:
     sk_sp<VertexBuffer> fVB;
     sk_sp<IndexBuffer>  fIB;
 
+    sk_sp<const SkData> fUniforms;
+
     size_t fVOffset = 0;  // Must be a multiple of spec->stride()
     size_t fVCount  = 0;
 

package/cpp/skia/include/core/SkMilestone.h

@@ -5,5 +5,5 @@
  * found in the LICENSE file.
  */
 #ifndef SK_MILESTONE
-#define SK_MILESTONE 103
+#define SK_MILESTONE 108
 #endif

package/cpp/skia/include/core/SkOverdrawCanvas.h

@@ -22,7 +22,8 @@ public:
     SkOverdrawCanvas(SkCanvas*);
 
     void onDrawTextBlob(const SkTextBlob*, SkScalar, SkScalar, const SkPaint&) override;
-    void onDrawGlyphRunList(const SkGlyphRunList& glyphRunList, const SkPaint& paint) override;
+    void onDrawGlyphRunList(
+            const sktext::GlyphRunList& glyphRunList, const SkPaint& paint) override;
     void onDrawPatch(const SkPoint[12], const SkColor[4], const SkPoint[4], SkBlendMode,
                      const SkPaint&) override;
     void onDrawPaint(const SkPaint&) override;

package/cpp/skia/include/core/SkPaint.h

@@ -251,12 +251,14 @@ public:
 
     /** Retrieves alpha from the color used when stroking and filling.
 
-        @return  alpha ranging from zero, fully transparent, to 255, fully opaque
+        @return  alpha ranging from zero, fully transparent, to one, fully opaque
     */
     float getAlphaf() const { return fColor4f.fA; }
 
     // Helper that scales the alpha by 255.
-    uint8_t getAlpha() const { return sk_float_round2int(this->getAlphaf() * 255); }
+    uint8_t getAlpha() const {
+        return static_cast<uint8_t>(sk_float_round2int(this->getAlphaf() * 255));
+    }
 
     /** Replaces alpha, leaving RGB
         unchanged. An out of range value triggers an assert in the debug
@@ -676,6 +678,8 @@ public:
     const SkRect& doComputeFastBounds(const SkRect& orig, SkRect* storage,
                                       Style style) const;
 
+    using sk_is_trivially_relocatable = std::true_type;
+
 private:
     sk_sp<SkPathEffect>   fPathEffect;
     sk_sp<SkShader>       fShader;
@@ -699,6 +703,15 @@ private:
         uint32_t fBitfieldsUInt;
     };
 
+    static_assert(::sk_is_trivially_relocatable<decltype(fPathEffect)>::value);
+    static_assert(::sk_is_trivially_relocatable<decltype(fShader)>::value);
+    static_assert(::sk_is_trivially_relocatable<decltype(fMaskFilter)>::value);
+    static_assert(::sk_is_trivially_relocatable<decltype(fColorFilter)>::value);
+    static_assert(::sk_is_trivially_relocatable<decltype(fImageFilter)>::value);
+    static_assert(::sk_is_trivially_relocatable<decltype(fBlender)>::value);
+    static_assert(::sk_is_trivially_relocatable<decltype(fColor4f)>::value);
+    static_assert(::sk_is_trivially_relocatable<decltype(fBitfields)>::value);
+
     friend class SkPaintPriv;
 };
 

package/cpp/skia/include/core/SkPath.h

@@ -1756,6 +1756,8 @@ public:
     */
     bool isValid() const;
 
+    using sk_is_trivially_relocatable = std::true_type;
+
 private:
     SkPath(sk_sp<SkPathRef>, SkPathFillType, bool isVolatile, SkPathConvexity,
            SkPathFirstDirection firstDirection);
@@ -1767,6 +1769,8 @@ private:
     uint8_t                        fFillType    : 2;
     uint8_t                        fIsVolatile  : 1;
 
+    static_assert(::sk_is_trivially_relocatable<decltype(fPathRef)>::value);
+
     /** Resets all fields other than fPathRef to their initial 'empty' values.
      *  Assumes the caller has already emptied fPathRef.
      *  On Android increments fGenerationID without reseting it.

package/cpp/skia/include/core/SkPathBuilder.h

@@ -242,7 +242,7 @@ private:
     int fIsAStart = -1;     // tracks direction iff fIsA is not unknown
     bool fIsACCW  = false;  // tracks direction iff fIsA is not unknown
 
-    int countVerbs() const { return fVerbs.count(); }
+    int countVerbs() const { return fVerbs.size(); }
 
     // called right before we add a (non-move) verb
     void ensureMove() {

package/cpp/skia/include/core/SkPicture.h

@@ -240,7 +240,6 @@ private:
     friend class SkBigPicture;
     friend class SkEmptyPicture;
     friend class SkPicturePriv;
-    template <typename> friend class SkMiniPicture;
 
     void serialize(SkWStream*, const SkSerialProcs*, class SkRefCntSet* typefaces,
         bool textBlobsOnly=false) const;
@@ -263,8 +262,6 @@ private:
     // Returns NULL if this is not an SkBigPicture.
     virtual const class SkBigPicture* asSkBigPicture() const { return nullptr; }
 
-    friend struct SkPathCounter;
-
     static bool IsValidPictInfo(const struct SkPictInfo& info);
     static sk_sp<SkPicture> Forwardport(const struct SkPictInfo&,
                                         const class SkPictureData*,

package/cpp/skia/include/core/SkPictureRecorder.h

@@ -20,7 +20,6 @@ namespace android {
 
 class SkCanvas;
 class SkDrawable;
-class SkMiniRecorder;
 class SkPictureRecord;
 class SkRecord;
 class SkRecorder;
@@ -106,7 +105,6 @@ private:
     sk_sp<SkBBoxHierarchy>      fBBH;
     std::unique_ptr<SkRecorder> fRecorder;
     sk_sp<SkRecord>             fRecord;
-    std::unique_ptr<SkMiniRecorder> fMiniRecorder;
 
     SkPictureRecorder(SkPictureRecorder&&) = delete;
     SkPictureRecorder& operator=(SkPictureRecorder&&) = delete;

package/cpp/skia/include/core/SkPixmap.h

@@ -261,6 +261,25 @@ public:
     */
     SkColor getColor(int x, int y) const;
 
+    /** Returns pixel at (x, y) as unpremultiplied color as an SkColor4f.
+        Returns black with alpha if SkColorType is kAlpha_8_SkColorType.
+
+        Input is not validated: out of bounds values of x or y trigger an assert() if
+        built with SK_DEBUG defined; and returns undefined values or may crash if
+        SK_RELEASE is defined. Fails if SkColorType is kUnknown_SkColorType or
+        pixel address is nullptr.
+
+        SkColorSpace in SkImageInfo is ignored. Some color precision may be lost in the
+        conversion to unpremultiplied color; original pixel data may have additional
+        precision, though this is less likely than for getColor(). Rounding errors may
+        occur if the underlying type has lower precision.
+
+        @param x  column index, zero or greater, and less than width()
+        @param y  row index, zero or greater, and less than height()
+        @return   pixel converted to unpremultiplied float color
+    */
+    SkColor4f getColor4f(int x, int y) const;
+
     /** Look up the pixel at (x,y) and return its alpha component, normalized to [0..1].
         This is roughly equivalent to SkGetColorA(getColor()), but can be more efficent
         (and more precise if the pixels store more than 8 bits per component).

package/cpp/skia/include/core/SkRasterHandleAllocator.h

@@ -13,6 +13,7 @@
 class SkBitmap;
 class SkCanvas;
 class SkMatrix;
+class SkSurfaceProps;
 
 /**
  *  If a client wants to control the allocation of raster layers in a canvas, it should subclass
@@ -76,7 +77,8 @@ public:
      *  If rec is null, then the allocator will be called for the base-layer as well.
      */
     static std::unique_ptr<SkCanvas> MakeCanvas(std::unique_ptr<SkRasterHandleAllocator>,
-                                                const SkImageInfo&, const Rec* rec = nullptr);
+                                                const SkImageInfo&, const Rec* rec = nullptr,
+                                                const SkSurfaceProps* props = nullptr);
 
 protected:
     SkRasterHandleAllocator() = default;

package/cpp/skia/include/core/SkRect.h

@@ -215,7 +215,8 @@ struct SK_API SkIRect {
         @return   true if members are equal
     */
     friend bool operator==(const SkIRect& a, const SkIRect& b) {
-        return !memcmp(&a, &b, sizeof(a));
+        return a.fLeft == b.fLeft && a.fTop == b.fTop &&
+               a.fRight == b.fRight && a.fBottom == b.fBottom;
     }
 
     /** Returns true if any member in a: fLeft, fTop, fRight, and fBottom; is not
@@ -226,7 +227,8 @@ struct SK_API SkIRect {
         @return   true if members are not equal
     */
     friend bool operator!=(const SkIRect& a, const SkIRect& b) {
-        return !(a == b);
+        return a.fLeft != b.fLeft || a.fTop != b.fTop ||
+               a.fRight != b.fRight || a.fBottom != b.fBottom;
     }
 
     /** Sets SkIRect to (0, 0, 0, 0).
@@ -783,7 +785,7 @@ struct SK_API SkRect {
 
         @return  midpoint on x-axis
     */
-    SkScalar centerX() const {
+    constexpr SkScalar centerX() const {
         // don't use SkScalarHalf(fLeft + fBottom) as that might overflow before the 0.5
         return SkScalarHalf(fLeft) + SkScalarHalf(fRight);
     }
@@ -793,11 +795,16 @@ struct SK_API SkRect {
 
         @return  midpoint on y-axis
     */
-    SkScalar centerY() const {
+    constexpr SkScalar centerY() const {
         // don't use SkScalarHalf(fTop + fBottom) as that might overflow before the 0.5
         return SkScalarHalf(fTop) + SkScalarHalf(fBottom);
     }
 
+    /** Returns the point this->centerX(), this->centerY().
+        @return  rectangle center
+     */
+    constexpr SkPoint center() const { return {this->centerX(), this->centerY()}; }
+
     /** Returns true if all members in a: fLeft, fTop, fRight, and fBottom; are
         equal to the corresponding members in b.
 

package/cpp/skia/include/core/SkRefCnt.h

@@ -9,6 +9,7 @@
 #define SkRefCnt_DEFINED
 
 #include "include/core/SkTypes.h"
+#include "include/private/SkTemplates.h"
 
 #include <atomic>       // std::atomic, std::memory_order_*
 #include <cstddef>      // std::nullptr_t
@@ -211,8 +212,17 @@ private:
  *  This can be used for classes inheriting from SkRefCnt, but it also works for other
  *  classes that match the interface, but have different internal choices: e.g. the hosted class
  *  may have its ref/unref be thread-safe, but that is not assumed/imposed by sk_sp.
+ *
+ *  Declared with the trivial_abi attribute where supported so that sk_sp and types containing it
+ *  may be considered as trivially relocatable by the compiler so that destroying-move operations
+ *  i.e. move constructor followed by destructor can be optimized to memcpy.
  */
-template <typename T> class sk_sp {
+#if defined(__clang__) && defined(__has_cpp_attribute) && __has_cpp_attribute(clang::trivial_abi)
+#define SK_SP_TRIVIAL_ABI [[clang::trivial_abi]]
+#else
+#define SK_SP_TRIVIAL_ABI
+#endif
+template <typename T> class SK_SP_TRIVIAL_ABI sk_sp {
 public:
     using element_type = T;
 
@@ -327,6 +337,8 @@ public:
         swap(fPtr, that.fPtr);
     }
 
+    using sk_is_trivially_relocatable = std::true_type;
+
 private:
     T*  fPtr;
 };

package/cpp/skia/include/core/SkRegion.h

@@ -9,6 +9,7 @@
 #define SkRegion_DEFINED
 
 #include "include/core/SkRect.h"
+#include "include/private/SkTemplates.h"
 
 class SkPath;
 class SkRgnBuilder;
@@ -606,6 +607,8 @@ public:
     */
     size_t readFromMemory(const void* buffer, size_t length);
 
+    using sk_is_trivially_relocatable = std::true_type;
+
 private:
     static constexpr int kOpCount = kReplace_Op + 1;
 
@@ -629,6 +632,9 @@ private:
     SkIRect     fBounds;
     RunHead*    fRunHead;
 
+    static_assert(::sk_is_trivially_relocatable<decltype(fBounds)>::value);
+    static_assert(::sk_is_trivially_relocatable<decltype(fRunHead)>::value);
+
     void freeRuns();
 
     /**