@shopify/react-native-skia 1.3.12 → 1.4.0

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

@@ -12,9 +12,8 @@
 #include "include/core/SkFlattenable.h"
 
 /**
- * SkBlender represents a custom blend function in the Skia pipeline. When an SkBlender is
- * present in a paint, the SkBlendMode is ignored. A blender combines a source color (the
- * result of our paint) and destination color (from the canvas) into a final color.
+ * SkBlender represents a custom blend function in the Skia pipeline.  A blender combines a source
+ * color (the result of our paint) and destination color (from the canvas) into a final color.
  */
 class SK_API SkBlender : public SkFlattenable {
 public:

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

@@ -8,6 +8,7 @@
 #ifndef SkCanvas_DEFINED
 #define SkCanvas_DEFINED
 
+#include "include/core/SkArc.h"
 #include "include/core/SkBlendMode.h"
 #include "include/core/SkClipOp.h"
 #include "include/core/SkColor.h"
@@ -51,6 +52,7 @@ class GrRecordingContext;
 
 class SkBitmap;
 class SkBlender;
+class SkColorSpace;
 class SkData;
 class SkDevice;
 class SkDrawable;
@@ -78,6 +80,10 @@ class SkEnumBitMask;
 namespace skgpu::graphite { class Recorder; }
 namespace sktext::gpu { class Slug; }
 namespace SkRecords { class Draw; }
+namespace skiatest {
+template <typename Key>
+class TestCanvas;// IWYU pragma: keep
+}
 
 /** \class SkCanvas
     SkCanvas provides an interface for drawing, and how the drawing is clipped and transformed.
@@ -694,7 +700,7 @@ public:
             @return                SaveLayerRec with empty fBackdrop
         */
         SaveLayerRec(const SkRect* bounds, const SkPaint* paint, SaveLayerFlags saveLayerFlags = 0)
-            : SaveLayerRec(bounds, paint, nullptr, 1.f, saveLayerFlags, /*filters=*/{}) {}
+            : SaveLayerRec(bounds, paint, nullptr, nullptr, 1.f, saveLayerFlags, /*filters=*/{}) {}
 
         /** Sets fBounds, fPaint, fBackdrop, and fSaveLayerFlags.
 
@@ -710,7 +716,29 @@ public:
         */
         SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop,
                      SaveLayerFlags saveLayerFlags)
-            : SaveLayerRec(bounds, paint, backdrop, 1.f, saveLayerFlags, /*filters=*/{}) {}
+            : SaveLayerRec(bounds, paint, backdrop, nullptr, 1.f, saveLayerFlags, /*filters=*/{}) {}
+
+        /** Sets fBounds, fColorSpace, and fSaveLayerFlags.
+
+            @param bounds          layer dimensions; may be nullptr
+            @param paint           applied to layer when overlaying prior layer;
+                                   may be nullptr
+            @param backdrop        If not null, this causes the current layer to be filtered by
+                                   backdrop, and then drawn into the new layer
+                                   (respecting the current clip).
+                                   If null, the new layer is initialized with transparent-black.
+            @param colorSpace      If not null, when the layer is restored, a color space
+                                   conversion will be applied from this color space to the
+                                   parent's color space. The restore paint and backdrop filters will
+                                   be applied in this color space.
+                                   If null, the new layer will inherit the color space from its
+                                   parent.
+            @param saveLayerFlags  SaveLayerRec options to modify layer
+            @return                SaveLayerRec fully specified
+        */
+        SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop,
+                     const SkColorSpace* colorSpace, SaveLayerFlags saveLayerFlags)
+            : SaveLayerRec(bounds, paint, backdrop, colorSpace, 1.f, saveLayerFlags, /*filters=*/{}) {}
 
         /** hints at layer size limit */
         const SkRect*        fBounds         = nullptr;
@@ -728,6 +756,13 @@ public:
          */
         const SkImageFilter* fBackdrop       = nullptr;
 
+        /**
+         * If not null, this triggers a color space conversion when the layer is restored. It
+         * will be as if the layer's contents are drawn in this color space. Filters from
+         * fBackdrop and fPaint will be applied in this color space.
+         */
+        const SkColorSpace* fColorSpace      = nullptr;
+
         /** preserves LCD text, creates with prior layer contents */
         SaveLayerFlags       fSaveLayerFlags = 0;
 
@@ -738,6 +773,7 @@ public:
         SaveLayerRec(const SkRect* bounds,
                      const SkPaint* paint,
                      const SkImageFilter* backdrop,
+                     const SkColorSpace* colorSpace,
                      SkScalar backdropScale,
                      SaveLayerFlags saveLayerFlags,
                      FilterSpan filters)
@@ -745,6 +781,7 @@ public:
                 , fPaint(paint)
                 , fFilters(filters)
                 , fBackdrop(backdrop)
+                , fColorSpace(colorSpace)
                 , fSaveLayerFlags(saveLayerFlags)
                 , fExperimentalBackdropScale(backdropScale) {
             // We only allow the paint's image filter or the side-car list of filters -- not both.
@@ -1436,6 +1473,27 @@ public:
     void drawArc(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle,
                  bool useCenter, const SkPaint& paint);
 
+    /** Draws arc using clip, SkMatrix, and SkPaint paint.
+
+        Arc is part of oval bounded by oval, sweeping from startAngle to startAngle plus
+        sweepAngle. startAngle and sweepAngle are in degrees.
+
+        startAngle of zero places start point at the right middle edge of oval.
+        A positive sweepAngle places arc end point clockwise from start point;
+        a negative sweepAngle places arc end point counterclockwise from start point.
+        sweepAngle may exceed 360 degrees, a full circle.
+        If useCenter is true, draw a wedge that includes lines from oval
+        center to arc end points. If useCenter is false, draw arc between end points.
+
+        If SkRect oval is empty or sweepAngle is zero, nothing is drawn.
+
+        @param arc    SkArc specifying oval, startAngle, sweepAngle, and arc-vs-wedge
+        @param paint  SkPaint stroke or fill, blend, color, and so on, used to draw
+    */
+    void drawArc(const SkArc& arc, const SkPaint& paint) {
+        this->drawArc(arc.fOval, arc.fStartAngle, arc.fSweepAngle, arc.isWedge(), paint);
+    }
+
     /** Draws SkRRect bounded by SkRect rect, with corner radii (rx, ry) using clip,
         SkMatrix, and SkPaint paint.
 
@@ -2299,7 +2357,7 @@ protected:
 
     /**
      */
-    virtual void onDrawSlug(const sktext::gpu::Slug* slug);
+    virtual void onDrawSlug(const sktext::gpu::Slug* slug, const SkPaint& paint);
 
 private:
     enum class PredrawFlags : unsigned {
@@ -2351,10 +2409,15 @@ private:
         bool                                           fIsCoverage;
         bool                                           fDiscard;
 
+        // If true, the layer image is sized to include a 1px buffer that remains transparent
+        // to allow for faster linear filtering under complex transforms.
+        bool                                           fIncludesPadding;
+
         Layer(sk_sp<SkDevice> device,
               FilterSpan imageFilters,
               const SkPaint& paint,
-              bool isCoverage);
+              bool isCoverage,
+              bool includesPadding);
     };
 
     // Encapsulate state needed to restore from saveBehind()
@@ -2392,7 +2455,8 @@ private:
         void newLayer(sk_sp<SkDevice> layerDevice,
                       FilterSpan filters,
                       const SkPaint& restorePaint,
-                      bool layerIsCoverage);
+                      bool layerIsCoverage,
+                      bool includesPadding);
 
         void reset(SkDevice* device);
     };
@@ -2441,7 +2505,7 @@ private:
     friend class SkRasterHandleAllocator;
     friend class SkRecords::Draw;
     template <typename Key>
-    friend class SkTestCanvas;
+    friend class skiatest::TestCanvas;
 
 protected:
     // For use by SkNoDrawCanvas (via SkCanvasVirtualEnforcer, which can't be a friend)
@@ -2466,7 +2530,7 @@ private:
     /**
      * Draw an sktext::gpu::Slug given the current canvas state.
      */
-    void drawSlug(const sktext::gpu::Slug* slug);
+    void drawSlug(const sktext::gpu::Slug* slug, const SkPaint& paint);
 
     /** Experimental
      *  Saves the specified subset of the current pixels in the current layer,
@@ -2506,13 +2570,16 @@ private:
     void internalSave();
     void internalRestore();
 
-    enum class DeviceCompatibleWithFilter : bool {
+    enum class DeviceCompatibleWithFilter : int {
         // Check the src device's local-to-device matrix for compatibility with the filter, and if
         // it is not compatible, introduce an intermediate image and transformation that allows the
         // filter to be evaluated on the modified src content.
-        kUnknown = false,
+        kUnknown,
         // Assume that the src device's local-to-device matrix is compatible with the filter.
-        kYes     = true
+        kYes,
+        // Assume that the src device's local-to-device matrix is compatible with the filter,
+        // *and* the source image has a 1px buffer of padding.
+        kYesWithPadding
     };
     /**
      * Filters the contents of 'src' and draws the result into 'dst'. The filter is evaluated
@@ -2528,6 +2595,7 @@ private:
     void internalDrawDeviceWithFilter(SkDevice* src, SkDevice* dst,
                                       FilterSpan filters, const SkPaint& paint,
                                       DeviceCompatibleWithFilter compat,
+                                      const SkColorInfo& filterColorInfo,
                                       SkScalar scaleFactor = 1.f,
                                       bool srcIsCoverageLayer = false);
 
@@ -2539,12 +2607,6 @@ private:
     bool wouldOverwriteEntireSurface(const SkRect*, const SkPaint*,
                                      SkEnumBitMask<PredrawFlags>) const;
 
-    /**
-     *  Returns true if the paint's imagefilter can be invoked directly, without needed a layer.
-     */
-    bool canDrawBitmapAsSprite(SkScalar x, SkScalar y, int w, int h, const SkSamplingOptions&,
-                               const SkPaint&);
-
     /**
      *  Returns true if the clip (for any active layer) contains antialiasing.
      *  If the clip is empty, this will return false.
@@ -2568,6 +2630,14 @@ private:
     // into the canvas' global space.
     SkRect computeDeviceClipBounds(bool outsetForAA=true) const;
 
+    // Attempt to draw a rrect with an analytic blur. If the paint does not contain a blur, or the
+    // geometry can't be drawn with an analytic blur by the device, a layer is returned for a
+    // regular draw. If the draw succeeds or predrawNotify fails, nullopt is returned indicating
+    // that nothing further should be drawn.
+    std::optional<AutoLayerForImageFilter> attemptBlurredRRectDraw(const SkRRect&,
+                                                                   const SkPaint&,
+                                                                   SkEnumBitMask<PredrawFlags>);
+
     class AutoUpdateQRBounds;
     void validateClip() const;
 

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

@@ -14,9 +14,7 @@
 
 namespace SkSL { struct ShaderCaps; }
 
-#if defined(SK_GRAPHITE)
 namespace skgpu::graphite { class Caps; }
-#endif
 
 class SK_API SkCapabilities : public SkRefCnt {
 public:
@@ -25,9 +23,7 @@ public:
     SkSL::Version skslVersion() const { return fSkSLVersion; }
 
 protected:
-#if defined(SK_GRAPHITE)
     friend class skgpu::graphite::Caps; // for ctor
-#endif
 
     SkCapabilities() = default;
 

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

@@ -49,8 +49,6 @@ public:
     // Returns true if the filter is guaranteed to never change the alpha of a color it filters.
     bool isAlphaUnchanged() const;
 
-    SkColor filterColor(SkColor) const;
-
     /**
      * Converts the src color (in src colorspace), into the dst colorspace,
      * then applies this filter to it, returning the filtered color in the dst colorspace.
@@ -94,8 +92,10 @@ public:
     static sk_sp<SkColorFilter> Blend(const SkColor4f& c, sk_sp<SkColorSpace>, SkBlendMode mode);
     static sk_sp<SkColorFilter> Blend(SkColor c, SkBlendMode mode);
 
-    static sk_sp<SkColorFilter> Matrix(const SkColorMatrix&);
-    static sk_sp<SkColorFilter> Matrix(const float rowMajor[20]);
+    enum class Clamp : bool { kNo, kYes };
+
+    static sk_sp<SkColorFilter> Matrix(const SkColorMatrix&, Clamp clamp = Clamp::kYes);
+    static sk_sp<SkColorFilter> Matrix(const float rowMajor[20], Clamp clamp = Clamp::kYes);
 
     // A version of Matrix which operates in HSLA space instead of RGBA.
     // I.e. HSLA-to-RGBA(Matrix(RGBA-to-HSLA(input))).

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

@@ -100,22 +100,20 @@ static inline U8CPU SkUnitScalarClampToByte(SkScalar x) {
 #define SkB32Assert(b)  SkASSERT((unsigned)(b) <= SK_B32_MASK)
 
 /**
- *  Pack the components into a SkPMColor, checking (in the debug version) that
- *  the components are 0..255, and are already premultiplied (i.e. alpha >= color)
+ *  Pack the components into a SkPMColor
  */
 static inline SkPMColor SkPackARGB32(U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
     SkA32Assert(a);
-    SkASSERT(r <= a);
-    SkASSERT(g <= a);
-    SkASSERT(b <= a);
+    SkR32Assert(r);
+    SkG32Assert(g);
+    SkB32Assert(b);
 
     return (a << SK_A32_SHIFT) | (r << SK_R32_SHIFT) |
            (g << SK_G32_SHIFT) | (b << SK_B32_SHIFT);
 }
 
 /**
- *  Same as SkPackARGB32, but this version guarantees to not check that the
- *  values are premultiplied in the debug version.
+ *  Legacy "NoCheck" version of SkPackARGB32. Remove this once all callers are updated.
  */
 static inline SkPMColor SkPackARGB32NoCheck(U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
     return (a << SK_A32_SHIFT) | (r << SK_R32_SHIFT) |

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

@@ -29,6 +29,7 @@ enum SkColorType : int {
     kRGB_101010x_SkColorType,  //!< pixel with 10 bits each for red, green, blue; in 32-bit word
     kBGR_101010x_SkColorType,  //!< pixel with 10 bits each for blue, green, red; in 32-bit word
     kBGR_101010x_XR_SkColorType, //!< pixel with 10 bits each for blue, green, red; in 32-bit word, extended range
+    kBGRA_10101010_XR_SkColorType, //!< pixel with 10 bits each for blue, green, red, alpha; in 64-bit word, extended range
     kRGBA_10x6_SkColorType,    //!< pixel with 10 used bits (most significant) followed by 6 unused
                                //   bits for red, green, blue, alpha; in 64-bit word
     kGray_8_SkColorType,       //!< pixel with grayscale level in 8-bit byte
@@ -36,6 +37,7 @@ enum SkColorType : int {
                                //   in 64-bit word
     kRGBA_F16_SkColorType,     //!< pixel with half floats for red, green, blue, alpha;
                                //   in 64-bit word
+    kRGB_F16F16F16x_SkColorType,     //!< pixel with half floats for red, green, blue; in 64-bit word
     kRGBA_F32_SkColorType,     //!< pixel using C float for red, green, blue, alpha; in 128-bit word
 
     // The following 6 colortypes are just for reading from - not for rendering to

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

@@ -31,7 +31,7 @@ public:
         kSkColorFilter_Type,
         kSkBlender_Type,
         kSkDrawable_Type,
-        kSkDrawLooper_Type,  // no longer used internally by Skia
+        kSkDrawLooper_Type,  // no longer supported by Skia
         kSkImageFilter_Type,
         kSkMaskFilter_Type,
         kSkPathEffect_Type,

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

@@ -9,9 +9,11 @@
 #define SkFontArguments_DEFINED
 
 #include "include/core/SkColor.h"
-#include "include/core/SkScalar.h"
+#include "include/core/SkFourByteTag.h"
 #include "include/core/SkTypes.h"
 
+#include <cstdint>
+
 /** Represents a set of actual arguments for a font. */
 struct SkFontArguments {
     struct VariationPosition {

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

@@ -8,8 +8,9 @@
 #ifndef SkFontParameters_DEFINED
 #define SkFontParameters_DEFINED
 
-#include "include/core/SkScalar.h"
-#include "include/core/SkTypes.h"
+#include "include/core/SkFourByteTag.h"
+
+#include <cstdint>
 
 struct SkFontParameters {
     struct Variation {

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

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkFourByteTag_DEFINED
+#define SkFourByteTag_DEFINED
+
+#include <cstdint>
+
+using SkFourByteTag = uint32_t;
+
+static inline constexpr SkFourByteTag SkSetFourByteTag(char a, char b, char c, char d) {
+    return (((uint32_t)a << 24) | ((uint32_t)b << 16) | ((uint32_t)c << 8) | (uint32_t)d);
+}
+
+#endif

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

@@ -98,6 +98,8 @@ SK_API sk_sp<SkImage> RasterFromCompressedTextureData(sk_sp<SkData> data,
  *
  *  If the encoded format is not supported, nullptr is returned.
  *
+ *  If possible, clients should use SkCodecs::DeferredImage instead.
+ *
  *  @param encoded  the encoded data
  *  @return         created SkImage, or nullptr
 
@@ -466,6 +468,9 @@ public:
     /** Copies SkRect of pixels from SkImage to dstPixels. Copy starts at offset (srcX, srcY),
         and does not exceed SkImage (width(), height()).
 
+        Graphite has deprecated this API in favor of the equivalent asynchronous API on
+        skgpu::graphite::Context (with an optional explicit synchonization).
+
         dstInfo specifies width, height, SkColorType, SkAlphaType, and SkColorSpace of
         destination. dstRowBytes specifies the gap from one destination row to the next.
         Returns true if pixels are copied. Returns false if:
@@ -506,6 +511,9 @@ public:
     /** Copies a SkRect of pixels from SkImage to dst. Copy starts at (srcX, srcY), and
         does not exceed SkImage (width(), height()).
 
+        Graphite has deprecated this API in favor of the equivalent asynchronous API on
+        skgpu::graphite::Context (with an optional explicit synchonization).
+
         dst specifies width, height, SkColorType, SkAlphaType, SkColorSpace, pixel storage,
         and row bytes of destination. dst.rowBytes() specifics the gap from one destination
         row to the next. Returns true if pixels are copied. Returns false if:
@@ -557,8 +565,17 @@ public:
         AsyncReadResult& operator=(AsyncReadResult&&) = delete;
 
         virtual ~AsyncReadResult() = default;
+        /** Returns how many planes of data are in the result. e.g. 3 for YUV data. */
         virtual int count() const = 0;
+        /** Returns the raw pixel data for a given plane.
+         *
+         * It will be organized as per the dst SkImageInfo passed in to the async read call.
+         *
+         * Clients may wish to create an SkPixmap with this data using the dst SkImageInfo
+         * and rowBytes(i).
+         */
         virtual const void* data(int i) const = 0;
+        /** Returns how many bytes correspond to a single row of image data */
         virtual size_t rowBytes(int i) const = 0;
 
     protected:
@@ -585,10 +602,13 @@ public:
     /** Makes image pixel data available to caller, possibly asynchronously. It can also rescale
         the image pixels.
 
-        Currently asynchronous reads are only supported on the GPU backend and only when the
+        Currently asynchronous reads are only supported in the Ganesh GPU backend and only when the
         underlying 3D API supports transfer buffers and CPU/GPU synchronization primitives. In all
         other cases this operates synchronously.
 
+        For the Graphite backend this API has been deprecated in favor of the equivalent API
+        on skgpu::graphite::Context.
+
         Data is read from the source sub-rectangle, is optionally converted to a linear gamma, is
         rescaled to the size indicated by 'info', is then converted to the color space, color type,
         and alpha type of 'info'. A 'srcRect' that is not contained by the bounds of the image
@@ -692,6 +712,26 @@ public:
     bool scalePixels(const SkPixmap& dst, const SkSamplingOptions&,
                      CachingHint cachingHint = kAllow_CachingHint) const;
 
+    /**
+     * Create a new image by copying this image and scaling to fit the ImageInfo's dimensions
+     * and converting the pixels into the ImageInfo's ColorInfo.
+     * This is done retaining the domain (backend) of the image (e.g. gpu, raster)
+     *
+     * The Recorder parameter is required if the original image was created on a graphite Recorder,
+     * but must be nullptr if it was create in some other way (e.g. GrContext, raster, deferred).
+     *
+     * return nullptr if the requested ColorInfo is not supported,  its dimesions are out of range,
+     *  or if the recorder is null on a graphite Image.
+     */
+    sk_sp<SkImage> makeScaled(skgpu::graphite::Recorder*,
+                              const SkImageInfo&,
+                              const SkSamplingOptions&) const;
+
+    sk_sp<SkImage> makeScaled(const SkImageInfo& info,
+                              const SkSamplingOptions& sampling) const {
+        return this->makeScaled(nullptr, info, sampling);
+    }
+
     /** Returns encoded SkImage pixels as SkData, if SkImage was created from supported
         encoded stream format. Platform support for formats vary and may require building
         with one or more of: SK_ENCODE_JPEG, SK_ENCODE_PNG, SK_ENCODE_WEBP.

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

@@ -15,11 +15,6 @@
 #include "include/core/SkYUVAPixmaps.h"
 #include "include/private/base/SkAPI.h"
 
-#if defined(SK_GRAPHITE)
-#include "include/core/SkImage.h"
-#include "include/gpu/graphite/Recorder.h"
-#endif
-
 #include <cstddef>
 #include <cstdint>
 

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

@@ -76,6 +76,24 @@ enum SkYUVColorSpace : int {
     kBT2020_10bit_Limited_SkYUVColorSpace,
     kBT2020_12bit_Full_SkYUVColorSpace,
     kBT2020_12bit_Limited_SkYUVColorSpace,
+    kBT2020_16bit_Full_SkYUVColorSpace,
+    kBT2020_16bit_Limited_SkYUVColorSpace,
+    kFCC_Full_SkYUVColorSpace,                  //!< describes FCC range
+    kFCC_Limited_SkYUVColorSpace,
+    kSMPTE240_Full_SkYUVColorSpace,             //!< describes SMPTE240M range
+    kSMPTE240_Limited_SkYUVColorSpace,
+    kYDZDX_Full_SkYUVColorSpace,                //!< describes YDZDX range
+    kYDZDX_Limited_SkYUVColorSpace,
+    kGBR_Full_SkYUVColorSpace,                  //!< describes GBR range
+    kGBR_Limited_SkYUVColorSpace,
+    kYCgCo_8bit_Full_SkYUVColorSpace,           //!< describes YCgCo matrix
+    kYCgCo_8bit_Limited_SkYUVColorSpace,
+    kYCgCo_10bit_Full_SkYUVColorSpace,
+    kYCgCo_10bit_Limited_SkYUVColorSpace,
+    kYCgCo_12bit_Full_SkYUVColorSpace,
+    kYCgCo_12bit_Limited_SkYUVColorSpace,
+    kYCgCo_16bit_Full_SkYUVColorSpace,
+    kYCgCo_16bit_Limited_SkYUVColorSpace,
     kIdentity_SkYUVColorSpace,                  //!< maps Y->R, U->G, V->B
 
     kLastEnum_SkYUVColorSpace = kIdentity_SkYUVColorSpace, //!< last valid value
@@ -87,6 +105,8 @@ enum SkYUVColorSpace : int {
     kBT2020_SkYUVColorSpace = kBT2020_8bit_Limited_SkYUVColorSpace,
 };
 
+SK_API bool SkYUVColorSpaceIsLimitedRange(SkYUVColorSpace cs);
+
 /** \struct SkColorInfo
     Describes pixel and encoding. SkImageInfo can be created from SkColorInfo by
     providing dimensions.

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

@@ -375,7 +375,7 @@ public:
 
         @return  true if matrix has only finite elements
     */
-    bool isFinite() const { return SkScalarsAreFinite(fMat, 16); }
+    bool isFinite() const { return SkIsFinite(fMat, 16); }
 
     /** If this is invertible, return that in inverse and return true. If it is
      *  not invertible, return false and leave the inverse parameter unchanged.

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

@@ -12,6 +12,7 @@
 #include "include/core/SkRect.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkTypes.h"
+#include "include/private/base/SkFloatingPoint.h"
 #include "include/private/base/SkMacros.h"
 #include "include/private/base/SkTo.h"
 
@@ -1830,7 +1831,7 @@ public:
 
         @return  true if matrix has only finite elements
     */
-    bool isFinite() const { return SkScalarsAreFinite(fMat, 9); }
+    bool isFinite() const { return SkIsFinite(fMat, 9); }
 
 private:
     /** Set if the matrix will map a rectangle to another rectangle. This

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

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

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

@@ -177,7 +177,7 @@ public:
     }
 
     /** Requests, but does not require, to distribute color error.
-        @param dither  setting for ditering
+        @param dither  setting for dithering
     */
     void setDither(bool dither) { fBitfields.fDither = static_cast<unsigned>(dither); }
 

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

@@ -137,6 +137,18 @@ public:
     */
     ~SkPath();
 
+    /** Returns a copy of this path in the current state. */
+    SkPath snapshot() const {
+        return *this;
+    }
+
+    /** Returns a copy of this path in the current state, and resets the path to empty. */
+    SkPath detach() {
+        SkPath result = *this;
+        this->reset();
+        return result;
+    }
+
     /** Constructs a copy of an existing path.
         SkPath assignment makes two paths identical by value. Internally, assignment
         shares pointer values. The underlying verb array, SkPoint array and weights
@@ -537,15 +549,17 @@ public:
     */
     bool conservativelyContainsRect(const SkRect& rect) const;
 
-    /** Grows SkPath verb array and SkPoint array to contain extraPtCount additional SkPoint.
+    /** Grows SkPath verb array, SkPoint array, and conics to contain additional space.
         May improve performance and use less memory by
         reducing the number and size of allocations when creating SkPath.
 
         @param extraPtCount  number of additional SkPoint to allocate
+        @param extraVerbCount  number of additional verbs
+        @param extraConicCount  number of additional conics
 
         example: https://fiddle.skia.org/c/@Path_incReserve
     */
-    void incReserve(int extraPtCount);
+    void incReserve(int extraPtCount, int extraVerbCount = 0, int extraConicCount = 0);
 
 #ifdef SK_HIDE_PATH_EDIT_METHODS
 private:
@@ -1332,8 +1346,9 @@ public:
         @param dx  offset added to SkPoint array x-axis coordinates
         @param dy  offset added to SkPoint array y-axis coordinates
     */
-    void offset(SkScalar dx, SkScalar dy) {
+    SkPath& offset(SkScalar dx, SkScalar dy) {
         this->offset(dx, dy, this);
+        return *this;
     }
 
     /** Transforms verb array, SkPoint array, and weight by matrix.
@@ -1357,9 +1372,10 @@ public:
         @param matrix  SkMatrix to apply to SkPath
         @param pc      whether to apply perspective clipping
     */
-    void transform(const SkMatrix& matrix,
+    SkPath& transform(const SkMatrix& matrix,
                    SkApplyPerspectiveClip pc = SkApplyPerspectiveClip::kYes) {
         this->transform(matrix, this, pc);
+        return *this;
     }
 
     SkPath makeTransform(const SkMatrix& m,
@@ -1790,7 +1806,6 @@ private:
 
     /** 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.
      */
     void resetFields();
 
@@ -1802,7 +1817,6 @@ private:
 
     size_t writeToMemoryAsRRect(void* buffer) const;
     size_t readAsRRect(const void*, size_t);
-    size_t readFromMemory_EQ4Or5(const void*, size_t);
 
     friend class Iter;
     friend class SkPathPriv;

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

@@ -13,6 +13,7 @@
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
 #include "include/private/base/SkAPI.h"
+#include "include/private/base/SkDebug.h"
 
 class SkMatrix;
 class SkPath;