@shopify/react-native-skia 2.6.0 → 2.6.2

package/cpp/rnwgpu/api/descriptors/Unions.h

@@ -463,8 +463,6 @@ inline void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::FeatureName::PixelLocalStorageNonCoherent;
   } else if (inUnion == "unorm16-texture-formats") {
     *outEnum = wgpu::FeatureName::Unorm16TextureFormats;
-  } else if (inUnion == "snorm16-texture-formats") {
-    *outEnum = wgpu::FeatureName::Snorm16TextureFormats;
   } else if (inUnion == "multi-planar-format-extended-usages") {
     *outEnum = wgpu::FeatureName::MultiPlanarFormatExtendedUsages;
   } else if (inUnion == "multi-planar-format-p010") {
@@ -485,12 +483,8 @@ inline void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::FeatureName::AdapterPropertiesD3D;
   } else if (inUnion == "adapter-properties-vk") {
     *outEnum = wgpu::FeatureName::AdapterPropertiesVk;
-  } else if (inUnion == "r8unorm-storage") {
-    *outEnum = wgpu::FeatureName::R8UnormStorage;
   } else if (inUnion == "format-capabilities") {
     *outEnum = wgpu::FeatureName::DawnFormatCapabilities;
-  } else if (inUnion == "norm16-texture-formats") {
-    *outEnum = wgpu::FeatureName::Norm16TextureFormats;
   } else if (inUnion == "multi-planar-format-nv16") {
     *outEnum = wgpu::FeatureName::MultiPlanarFormatNv16;
   } else if (inUnion == "multi-planar-format-nv24") {
@@ -629,9 +623,6 @@ inline void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::Unorm16TextureFormats:
     *outUnion = "unorm16-texture-formats";
     break;
-  case wgpu::FeatureName::Snorm16TextureFormats:
-    *outUnion = "snorm16-texture-formats";
-    break;
   case wgpu::FeatureName::MultiPlanarFormatExtendedUsages:
     *outUnion = "multi-planar-format-extended-usages";
     break;
@@ -662,12 +653,6 @@ inline void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::AdapterPropertiesVk:
     *outUnion = "adapter-properties-vk";
     break;
-  case wgpu::FeatureName::R8UnormStorage:
-    *outUnion = "r8unorm-storage";
-    break;
-  case wgpu::FeatureName::Norm16TextureFormats:
-    *outUnion = "norm16-texture-formats";
-    break;
   case wgpu::FeatureName::MultiPlanarFormatNv16:
     *outUnion = "multi-planar-format-nv16";
     break;

package/cpp/skia/include/android/SkImageAndroid.h

@@ -52,11 +52,16 @@ SK_API sk_sp<SkImage> TextureFromAHardwareBufferWithData(
         GrSurfaceOrigin surfaceOrigin = kTopLeft_GrSurfaceOrigin);
 
 /**
- *  Like SkImagePriv::SkMakeImageFromRasterBitmap, except this can be pinned using
- *  skgpu::ganesh::PinAsTexture and CopyPixelMode is never.
+ *  Like SkImage::MakeFromBitmap, except this can be pinned using
+ *  skgpu::ganesh::PinAsTexture and Skia will *not* copy the bitmap.
  */
 SK_API sk_sp<SkImage> PinnableRasterFromBitmap(const SkBitmap&);
 
+/**
+ * Like SkImage::MakeFromBitmap, except and Skia will *not* copy the bitmap.
+ */
+SK_API sk_sp<SkImage> RasterFromBitmapNoCopy(const SkBitmap&);
+
 }  // namespace SkImages
 
 namespace skgpu::ganesh {

package/cpp/skia/include/android/vk/AndroidVulkanMemoryAllocator.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef AndroidVulkanMemoryAllocator_DEFINED
+#define AndroidVulkanMemoryAllocator_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+namespace skgpu {
+struct VulkanBackendContext;
+class VulkanMemoryAllocator;
+}
+
+namespace SkiaVMA {
+
+struct Options {
+    bool fThreadSafe = true;
+};
+
+// Returns a concrete implementation of a memory allocator using some hard-coded settings.
+// If Android Framework ever wants to make their own, they can stop using this.
+sk_sp<skgpu::VulkanMemoryAllocator> Make(const skgpu::VulkanBackendContext&, Options);
+
+}  // namespace SkiaVMA
+
+#endif

package/cpp/skia/include/codec/SkCodec.h

@@ -122,6 +122,10 @@ public:
          *  FIXME: Perhaps this should be kUnsupported?
          */
         kUnimplemented,
+        /**
+         *  If the memory allocation exceeded the provided budget.
+         */
+        kOutOfMemory,
     };
 
     /**
@@ -308,12 +312,6 @@ public:
      */
     SkEncodedImageFormat getEncodedFormat() const { return this->onGetEncodedFormat(); }
 
-    /**
-     *  Return the underlying encoded data stream. This may be nullptr if the original
-     *  stream could not be duplicated.
-     */
-    virtual std::unique_ptr<SkStream> getEncodedData() const;
-
     /**
      *  Whether or not the memory passed to getPixels is zero initialized.
      */
@@ -337,13 +335,13 @@ public:
      */
     struct Options {
         Options()
-            : fZeroInitialized(kNo_ZeroInitialized)
-            , fSubset(nullptr)
-            , fFrameIndex(0)
-            , fPriorFrame(kNoFrame)
-        {}
+                : fZeroInitialized(kNo_ZeroInitialized)
+                , fSubset(nullptr)
+                , fFrameIndex(0)
+                , fPriorFrame(kNoFrame)
+                , fMaxDecodeMemory(0) {}
 
-        ZeroInitialized            fZeroInitialized;
+        ZeroInitialized fZeroInitialized;
         /**
          *  If not NULL, represents a subset of the original image to decode.
          *  Must be within the bounds returned by getInfo().
@@ -361,14 +359,14 @@ public:
          *  subset left and subset width to decode partial scanlines on calls
          *  to getScanlines().
          */
-        const SkIRect*             fSubset;
+        const SkIRect* fSubset;
 
         /**
          *  The frame to decode.
          *
          *  Only meaningful for multi-frame images.
          */
-        int                        fFrameIndex;
+        int fFrameIndex;
 
         /**
          *  If not kNoFrame, the dst already contains the prior frame at this index.
@@ -383,7 +381,12 @@ public:
          *
          *  If set to kNoFrame, the codec will decode any necessary required frame(s) first.
          */
-        int                        fPriorFrame;
+        int fPriorFrame;
+
+        /**
+         * If non-zero, image decoding will fail if cumulative allocations exceed this many bytes.
+         */
+        size_t fMaxDecodeMemory;
     };
 
     /**
@@ -985,6 +988,9 @@ protected:
         return IsAnimated::kNo;
     }
 
+    // Returns true if the requested amount keeps the current total under Options::fMaxDecodeMemory.
+    bool allocateFromBudget(size_t numBytes);
+
 private:
     const SkEncodedInfo                fEncodedInfo;
     XformFormat                        fSrcXformFormat;
@@ -1013,6 +1019,9 @@ private:
     // Only meaningful during scanline decodes.
     int fCurrScanline = -1;
 
+    // How many bytes we are allowed to use when decoding.
+    size_t fDecodeBudget = 0;
+
     bool fStartedIncrementalDecode = false;
 
     // Allows SkAndroidCodec to call handleFrameIndex (potentially decoding a prior frame and
@@ -1034,6 +1043,11 @@ private:
         return dim == this->dimensions() || this->onDimensionsSupported(dim);
     }
 
+    Result getPixelsBudgeted(const SkImageInfo& info,
+                             void* pixels,
+                             size_t rowBytes,
+                             const Options*);
+
     /**
      *  For multi-framed images, return the object with information about the frames.
      */
@@ -1065,6 +1079,13 @@ private:
         return kUnimplemented;
     }
 
+    /**
+     *  Checks whether the implementation supports incremental decoding for the given info.
+     *
+     *  Note that onStartIncrementalDecode can stil fail regardless of this result.
+     */
+    virtual bool onSupportsIncrementalDecode(const SkImageInfo&) { return false; }
+
     virtual Result onStartIncrementalDecode(const SkImageInfo& /*dstInfo*/, void*, size_t,
             const Options&) {
         return kUnimplemented;
@@ -1106,6 +1127,12 @@ private:
      */
     virtual SkSampler* getSampler(bool /*createIfNecessary*/) { return nullptr; }
 
+    /**
+     *  Return the underlying encoded data. This may be nullptr if the original
+     *  stream could not be duplicated/read.
+     */
+    virtual sk_sp<const SkData> getEncodedData() const;
+
     friend class DM::CodecSrc;  // for fillIncompleteImage
     friend class PNGCodecGM;    // for fillIncompleteImage
     friend class SkSampledCodec;

package/cpp/skia/include/config/SkUserConfig.h

@@ -130,4 +130,12 @@
  */
 // #define SK_DNG_VERSION 0x01040000
 
+/*
+ * By default, Skia uses SIMD operations for many internal calculations, especially
+ * for the CPU backend. These defines can be set to disable SIMD in SkVx and
+ * SkRasterPipeline, respectively.
+ */
+// #define SKVX_DISABLE_SIMD
+// #define SKRP_CPU_SCALAR
+
 #endif

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

@@ -33,7 +33,6 @@ class SkPixelRef;
 class SkShader;
 enum SkColorType : int;
 enum class SkTileMode;
-struct SkMaskBuilder;
 
 /** \class SkBitmap
     SkBitmap describes a two-dimensional raster pixel array. SkBitmap is built on
@@ -645,10 +644,6 @@ public:
     */
     bool installPixels(const SkPixmap& pixmap);
 
-    /** Deprecated.
-    */
-    bool installMaskPixels(SkMaskBuilder& mask);
-
     /** Replaces SkPixelRef with pixels, preserving SkImageInfo and rowBytes().
         Sets SkPixelRef origin to (0, 0).
 

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

@@ -1328,11 +1328,6 @@ public:
         example: https://fiddle.skia.org/c/@Canvas_drawPoints
     */
     void drawPoints(PointMode mode, SkSpan<const SkPoint>, const SkPaint& paint);
-#ifdef SK_SUPPORT_UNSPANNED_APIS
-    void drawPoints(PointMode mode, size_t count, const SkPoint pts[], const SkPaint& paint) {
-        this->drawPoints(mode, {pts, count}, paint);
-    }
-#endif
 
     /** Draws point at (x, y) using clip, SkMatrix and SkPaint paint.
 
@@ -1915,17 +1910,6 @@ public:
     void drawGlyphs(SkSpan<const SkGlyphID> glyphs, SkSpan<const SkPoint> positions,
                     SkSpan<const uint32_t> clusters, SkSpan<const char> utf8text,
                     SkPoint origin, const SkFont& font, const SkPaint& paint);
-#ifdef SK_SUPPORT_UNSPANNED_APIS
-    void drawGlyphs(int count, const SkGlyphID glyphs[], const SkPoint positions[],
-                    const uint32_t clusters[], int textByteCount, const char utf8text[],
-                    SkPoint origin, const SkFont& font, const SkPaint& paint) {
-        this->drawGlyphs({glyphs,    count},
-                         {positions, count},
-                         {clusters,  count},
-                         {utf8text,  textByteCount},
-                         origin, font, paint);
-    }
-#endif
 
     /** Draws count glyphs, at positions relative to origin styled with font and paint.
 
@@ -1947,12 +1931,6 @@ public:
     */
     void drawGlyphs(SkSpan<const SkGlyphID> glyphs, SkSpan<const SkPoint> positions,
                     SkPoint origin, const SkFont& font, const SkPaint& paint);
-#ifdef SK_SUPPORT_UNSPANNED_APIS
-    void drawGlyphs(int count, const SkGlyphID glyphs[], const SkPoint positions[],
-                    SkPoint origin, const SkFont& font, const SkPaint& paint) {
-        this->drawGlyphs({glyphs, count}, {positions, count}, origin, font, paint);
-    }
-#endif
 
     /** Draws count glyphs, at positions relative to origin styled with font and paint.
 
@@ -1975,12 +1953,6 @@ public:
     */
     void drawGlyphsRSXform(SkSpan<const SkGlyphID> glyphs, SkSpan<const SkRSXform> xforms,
                            SkPoint origin, const SkFont& font, const SkPaint& paint);
-#ifdef SK_SUPPORT_UNSPANNED_APIS
-    void drawGlyphs(int count, const SkGlyphID glyphs[], const SkRSXform xforms[],
-                    SkPoint origin, const SkFont& font, const SkPaint& paint) {
-        this->drawGlyphsRSXform({glyphs, count}, {xforms, count}, origin, font, paint);
-    }
-#endif
 
     /** Draws SkTextBlob blob at (x, y), using clip, SkMatrix, and SkPaint paint.
 
@@ -2209,17 +2181,6 @@ public:
     void drawAtlas(const SkImage* atlas, SkSpan<const SkRSXform> xform,
                    SkSpan<const SkRect> tex, SkSpan<const SkColor> colors, SkBlendMode mode,
                    const SkSamplingOptions& sampling, const SkRect* cullRect, const SkPaint* paint);
-#ifdef SK_SUPPORT_UNSPANNED_APIS
-    void drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[],
-                   const SkColor colors[], int count, SkBlendMode mode,
-                   const SkSamplingOptions& samp, const SkRect* cullRect, const SkPaint* paint) {
-        this->drawAtlas(atlas,
-                        {xform, count},
-                        {tex, tex ? count : 0},
-                        {colors, colors ? count : 0},
-                        mode, samp, cullRect, paint);
-    }
-#endif
 
     /** Draws SkDrawable drawable using clip and SkMatrix, concatenated with
         optional matrix.
@@ -2648,6 +2609,8 @@ private:
 
     void init(sk_sp<SkDevice>);
 
+    bool nothingToDraw(const SkPaint& paint) const;
+
     // All base onDrawX() functions should call this and skip drawing if it returns true.
     // If 'matrix' is non-null, it maps the paint's fast bounds before checking for quick rejection
     bool internalQuickReject(const SkRect& bounds, const SkPaint& paint,

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

@@ -425,6 +425,18 @@ struct SkRGBA4f {
     SkRGBA4f pinAlpha() const {
         return { fR, fG, fB, SkTPin(fA, 0.f, 1.f) };
     }
+
+    /** Returns this color, having replaced its alpha value.
+     */
+    SkRGBA4f withAlpha(float a) const {
+        return { fR, fG, fB, a };
+    }
+
+    /** Returns this color, having replaced its alpha value specified as a byte.
+     */
+    SkRGBA4f withAlphaByte(uint8_t a) const {
+        return { fR, fG, fB, a/255.f };
+    }
 };
 
 /** \struct SkColor4f

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

@@ -37,8 +37,17 @@ struct SK_API SkColorSpacePrimaries {
      *  representation of SkColorSpace.
      */
     bool toXYZD50(skcms_Matrix3x3* toXYZD50) const;
+
+    bool operator==(const SkColorSpacePrimaries& other) const {
+        return fRX == other.fRX && fRY == other.fRY && fGX == other.fGX && fGY == other.fGY &&
+               fBX == other.fBX && fBY == other.fBY && fWX == other.fWX && fWY == other.fWY;
+    }
 };
 
+// TODO(https://issuetracker.google.com/issues/40044808): Remove this when no longer needed by
+// Chromium.
+#define SKIA_COLOR_SPACE_PRIMARIES_OPERATOR_EQUAL
+
 namespace SkNamedPrimaries {
 
 ////////////////////////////////////////////////////////////////////////////////

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

@@ -48,7 +48,7 @@ public:
     [[nodiscard]] bool getMatrix(SkScalar distance, SkMatrix* matrix,
                                  MatrixFlags flags = kGetPosAndTan_MatrixFlag) const;
 
-    /** Given a start and stop distance, return in dst the intervening segment(s).
+    /** Given a start and stop distance, append to dst the intervening segment(s).
      If the segment is zero-length, return false, else return true.
      startD and stopD are pinned to legal values (0..getLength()). If startD > stopD
      then return false (and leave dst untouched).
@@ -56,10 +56,6 @@ public:
      */
     [[nodiscard]] bool getSegment(SkScalar startD, SkScalar stopD, SkPathBuilder* dst,
                                   bool startWithMoveTo) const;
-#ifdef SK_SUPPORT_MUTABLE_PATHEFFECT
-    [[nodiscard]] bool getSegment(SkScalar startD, SkScalar stopD, SkPath* dst,
-                                  bool startWithMoveTo) const;
-#endif
 
     /** Return true if the contour is closed()
      */

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

@@ -39,6 +39,14 @@ public:
         return (other != nullptr) && *this == *other;
     }
 
+    /**
+     * Return true if both arguments are the same size and contain the same bytes, or if both
+     * arguments are null.
+     */
+    static bool Equals(const SkData* a, const SkData* b) {
+        return (a == nullptr) ? (b == nullptr) : a->equals(b);
+    }
+
     /**
      *  Returns the number of bytes stored.
      */

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

@@ -8,7 +8,7 @@
 #ifndef SkFont_DEFINED
 #define SkFont_DEFINED
 
-#include "include/core/SkPath.h"  // IWYU pragma: keep (for SK_HIDE_PATH_EDIT_METHODS)
+#include "include/core/SkPath.h"
 #include "include/core/SkPoint.h" // IWYU pragma: keep (for unspanned apis)
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
@@ -442,10 +442,6 @@ public:
      */
     std::optional<SkPath> getPath(SkGlyphID glyphID) const;
 
-#ifndef SK_HIDE_PATH_EDIT_METHODS
-    bool getPath(SkGlyphID glyphID, SkPath* path) const;
-#endif
-
     /** Returns path corresponding to glyph array.
 
         @param glyphIDs      array of glyph indices
@@ -486,56 +482,6 @@ public:
 
     using sk_is_trivially_relocatable = std::true_type;
 
-#ifdef SK_SUPPORT_UNSPANNED_APIS
-    int textToGlyphs(const void* text, size_t byteLength, SkTextEncoding encoding,
-                     SkGlyphID glyphs[], int maxGlyphCount) const {
-        return (int)this->textToGlyphs(text, byteLength, encoding, {glyphs, maxGlyphCount});
-    }
-    void unicharsToGlyphs(const SkUnichar uni[], int count, SkGlyphID glyphs[]) const {
-        this->unicharsToGlyphs({uni, count}, {glyphs, count});
-    }
-
-    void getPos(const SkGlyphID glyphs[], int count, SkPoint pos[], SkPoint origin = {0, 0}) const {
-        this->getPos({glyphs, count}, {pos, count}, origin);
-    }
-    void getXPos(const SkGlyphID glyphs[], int count, SkScalar xpos[], SkScalar origin = 0) const {
-        this->getXPos({glyphs, count}, {xpos, count}, origin);
-    }
-    void getPaths(const SkGlyphID glyphIDs[], int count,
-                  void (*glyphPathProc)(const SkPath* pathOrNull, const SkMatrix& mx, void* ctx),
-                  void* ctx) const {
-        this->getPaths({glyphIDs, count}, glyphPathProc, ctx);
-    }
-    void getWidthsBounds(const SkGlyphID glyphs[], int count, SkScalar widths[], SkRect bounds[],
-                         const SkPaint* paint) const {
-        const auto nw = widths ? count : 0;
-        const auto nb = bounds ? count : 0;
-        this->getWidthsBounds({glyphs, count}, {widths, nw}, {bounds, nb}, paint);
-    }
-    void getWidths(const SkGlyphID glyphs[], int count, SkScalar widths[], SkRect bounds[]) const {
-        const auto nw = widths ? count : 0;
-        const auto nb = bounds ? count : 0;
-        this->getWidthsBounds({glyphs, count}, {widths, nw}, {bounds, nb}, nullptr);
-    }
-    void getWidths(const SkGlyphID glyphs[], int count, SkScalar widths[], std::nullptr_t) const {
-        this->getWidthsBounds({glyphs, count}, {widths, count}, {}, nullptr);
-    }
-    void getWidths(const SkGlyphID glyphs[], int count, SkScalar widths[]) const {
-        this->getWidthsBounds({glyphs, count}, {widths, count}, {}, nullptr);
-    }
-    void getBounds(const SkGlyphID glyphs[], int count, SkRect bounds[],
-                   const SkPaint* paint) const {
-        this->getWidthsBounds({glyphs, count}, {}, {bounds, count}, paint);
-    }
-
-    std::vector<SkScalar> getIntercepts(const SkGlyphID glyphs[], int count, const SkPoint pos[],
-                                        SkScalar top, SkScalar bottom,
-                                        const SkPaint* paint = nullptr) const {
-        return this->getIntercepts({glyphs, count}, {pos, count}, top, bottom, paint);
-    }
-#endif
-
-
 private:
     enum PrivFlags {
         kForceAutoHinting_PrivFlag      = 1 << 0,

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

@@ -13,6 +13,7 @@
 #include "include/core/SkTypes.h"
 
 #include <cstdint>
+#include <optional>
 
 /** Represents a set of actual arguments for a font. */
 struct SkFontArguments {
@@ -87,10 +88,24 @@ struct SkFontArguments {
 
     Palette getPalette() const { return fPalette; }
 
+    SkFontArguments& setSyntheticBold(std::optional<bool> bold) {
+        fSyntheticBold = bold;
+        return *this;
+    }
+    std::optional<bool> getSyntheticBold() const { return fSyntheticBold; }
+
+    SkFontArguments& setSyntheticOblique(std::optional<bool> oblique) {
+        fSyntheticOblique = oblique;
+        return *this;
+    }
+    std::optional<bool> getSyntheticOblique() const { return fSyntheticOblique; }
+
 private:
     int fCollectionIndex;
     VariationPosition fVariationDesignPosition;
     Palette fPalette;
+    std::optional<bool> fSyntheticBold;
+    std::optional<bool> fSyntheticOblique;
 };
 
 #endif

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

@@ -140,13 +140,8 @@ public:
      */
     static void PurgeAllCaches();
 
-#if defined(SK_DISABLE_LEGACY_NONCONST_ENCODED_IMAGE_DATA)
     using ImageGeneratorFromEncodedDataFactory =
             std::unique_ptr<SkImageGenerator> (*)(sk_sp<const SkData>);
-#else
-    using ImageGeneratorFromEncodedDataFactory =
-            std::unique_ptr<SkImageGenerator> (*)(sk_sp<SkData>);
-#endif
 
     /**
      *  To instantiate images from encoded data, first looks at this runtime function-ptr. If it

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

@@ -739,11 +739,7 @@ public:
 
         example: https://fiddle.skia.org/c/@Image_refEncodedData
     */
-#if defined(SK_DISABLE_LEGACY_NONCONST_ENCODED_IMAGE_DATA)
     sk_sp<const SkData> refEncodedData() const;
-#else
-    sk_sp<SkData> refEncodedData() const;
-#endif
 
     struct RequiredProperties {
         bool fMipmapped = false;

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

@@ -116,11 +116,8 @@ protected:
 
     SkImageGenerator(const SkImageInfo& info, uint32_t uniqueId = kNeedNewImageUniqueID);
 
-#if defined(SK_DISABLE_LEGACY_NONCONST_ENCODED_IMAGE_DATA)
     virtual sk_sp<const SkData> onRefEncodedData() { return nullptr; }
-#else
-    virtual sk_sp<SkData> onRefEncodedData() { return nullptr; }
-#endif
+
     struct Options {};
     virtual bool onGetPixels(const SkImageInfo&, void*, size_t, const Options&) { return false; }
     virtual bool onIsValid(SkRecorder*) const { return true; }

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

@@ -1740,43 +1740,6 @@ public:
     */
     bool isFinite() const { return SkIsFinite(fMat, 9); }
 
-#ifdef SK_SUPPORT_UNSPANNED_APIS
-    bool setPolyToPoly(const SkPoint src[], const SkPoint dst[], int count) {
-        return this->setPolyToPoly({src, count}, {dst, count});
-    }
-
-    void mapPoints(SkPoint dst[], const SkPoint src[], int count) const {
-        this->mapPoints({dst, count}, {src, count});
-    }
-    void mapPoints(SkPoint pts[], int count) const {
-        this->mapPoints(pts, pts, count);
-    }
-
-    void mapHomogeneousPoints(SkPoint3 dst[], const SkPoint3 src[], int count) const {
-        this->mapHomogeneousPoints({dst, count}, {src, count});
-    }
-    void mapHomogeneousPoints(SkPoint3 dst[], const SkPoint src[], int count) const {
-        this->mapPointsToHomogeneous({dst, count}, {src, count});
-    }
-
-    void mapVectors(SkVector dst[], const SkVector src[], int count) const {
-        this->mapVectors({dst, count}, {src, count});
-    }
-    void mapVectors(SkVector vecs[], int count) const {
-        this->mapVectors({vecs, count});
-    }
-    void mapXY(SkScalar x, SkScalar y, SkPoint* result) const {
-        *result = this->mapPoint({x, y});
-    }
-    SkPoint mapXY(SkScalar x, SkScalar y) const {
-        return this->mapPoint({x, y});
-    }
-    void mapVector(SkScalar dx, SkScalar dy, SkVector* result) const {
-        SkVector vec = { dx, dy };
-        this->mapVectors({result, 1}, {&vec, 1});
-    }
-#endif
-
 private:
     /** Set if the matrix will map a rectangle to another rectangle. This
         can be true if the matrix is scale-only, or rotates a multiple of

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

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