@shopify/react-native-skia 0.0.135

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

@@ -0,0 +1,336 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkYUVAPixmaps_DEFINED
+#define SkYUVAPixmaps_DEFINED
+
+#include "include/core/SkData.h"
+#include "include/core/SkImageInfo.h"
+#include "include/core/SkPixmap.h"
+#include "include/core/SkYUVAInfo.h"
+#include "include/private/SkTo.h"
+
+#include <array>
+#include <bitset>
+
+class GrImageContext;
+
+/**
+ * SkYUVAInfo combined with per-plane SkColorTypes and row bytes. Fully specifies the SkPixmaps
+ * for a YUVA image without the actual pixel memory and data.
+ */
+class SK_API SkYUVAPixmapInfo {
+public:
+    static constexpr auto kMaxPlanes = SkYUVAInfo::kMaxPlanes;
+
+    using PlaneConfig  = SkYUVAInfo::PlaneConfig;
+    using Subsampling  = SkYUVAInfo::Subsampling;
+
+    /**
+     * Data type for Y, U, V, and possibly A channels independent of how values are packed into
+     * planes.
+     **/
+    enum class DataType {
+        kUnorm8,          ///< 8 bit unsigned normalized
+        kUnorm16,         ///< 16 bit unsigned normalized
+        kFloat16,         ///< 16 bit (half) floating point
+        kUnorm10_Unorm2,  ///< 10 bit unorm for Y, U, and V. 2 bit unorm for alpha (if present).
+
+        kLast = kUnorm10_Unorm2
+    };
+    static constexpr int kDataTypeCnt = static_cast<int>(DataType::kLast) + 1;
+
+    class SK_API SupportedDataTypes {
+    public:
+        /** Defaults to nothing supported. */
+        constexpr SupportedDataTypes() = default;
+
+        /** Init based on texture formats supported by the context. */
+        SupportedDataTypes(const GrImageContext&);
+
+        /** All legal combinations of PlaneConfig and DataType are supported. */
+        static constexpr SupportedDataTypes All();
+
+        /**
+         * Checks whether there is a supported combination of color types for planes structured
+         * as indicated by PlaneConfig with channel data types as indicated by DataType.
+         */
+        constexpr bool supported(PlaneConfig, DataType) const;
+
+        /**
+         * Update to add support for pixmaps with numChannel channels where each channel is
+         * represented as DataType.
+         */
+        void enableDataType(DataType, int numChannels);
+
+    private:
+        // The bit for DataType dt with n channels is at index kDataTypeCnt*(n-1) + dt.
+        std::bitset<kDataTypeCnt*4> fDataTypeSupport = {};
+    };
+
+    /**
+     * Gets the default SkColorType to use with numChannels channels, each represented as DataType.
+     * Returns kUnknown_SkColorType if no such color type.
+     */
+    static constexpr SkColorType DefaultColorTypeForDataType(DataType dataType, int numChannels);
+
+    /**
+     * If the SkColorType is supported for YUVA pixmaps this will return the number of YUVA channels
+     * that can be stored in a plane of this color type and what the DataType is of those channels.
+     * If the SkColorType is not supported as a YUVA plane the number of channels is reported as 0
+     * and the DataType returned should be ignored.
+     */
+    static std::tuple<int, DataType> NumChannelsAndDataType(SkColorType);
+
+    /** Default SkYUVAPixmapInfo is invalid. */
+    SkYUVAPixmapInfo() = default;
+
+    /**
+     * Initializes the SkYUVAPixmapInfo from a SkYUVAInfo with per-plane color types and row bytes.
+     * This will be invalid if the colorTypes aren't compatible with the SkYUVAInfo or if a
+     * rowBytes entry is not valid for the plane dimensions and color type. Color type and
+     * row byte values beyond the number of planes in SkYUVAInfo are ignored. All SkColorTypes
+     * must have the same DataType or this will be invalid.
+     *
+     * If rowBytes is nullptr then bpp*width is assumed for each plane.
+     */
+    SkYUVAPixmapInfo(const SkYUVAInfo&,
+                     const SkColorType[kMaxPlanes],
+                     const size_t rowBytes[kMaxPlanes]);
+    /**
+     * Like above but uses DefaultColorTypeForDataType to determine each plane's SkColorType. If
+     * rowBytes is nullptr then bpp*width is assumed for each plane.
+     */
+    SkYUVAPixmapInfo(const SkYUVAInfo&, DataType, const size_t rowBytes[kMaxPlanes]);
+
+    SkYUVAPixmapInfo(const SkYUVAPixmapInfo&) = default;
+
+    SkYUVAPixmapInfo& operator=(const SkYUVAPixmapInfo&) = default;
+
+    bool operator==(const SkYUVAPixmapInfo&) const;
+    bool operator!=(const SkYUVAPixmapInfo& that) const { return !(*this == that); }
+
+    const SkYUVAInfo& yuvaInfo() const { return fYUVAInfo; }
+
+    SkYUVColorSpace yuvColorSpace() const { return fYUVAInfo.yuvColorSpace(); }
+
+    /** The number of SkPixmap planes, 0 if this SkYUVAPixmapInfo is invalid. */
+    int numPlanes() const { return fYUVAInfo.numPlanes(); }
+
+    /** The per-YUV[A] channel data type. */
+    DataType dataType() const { return fDataType; }
+
+    /**
+     * Row bytes for the ith plane. Returns zero if i >= numPlanes() or this SkYUVAPixmapInfo is
+     * invalid.
+     */
+    size_t rowBytes(int i) const { return fRowBytes[static_cast<size_t>(i)]; }
+
+    /** Image info for the ith plane, or default SkImageInfo if i >= numPlanes() */
+    const SkImageInfo& planeInfo(int i) const { return fPlaneInfos[static_cast<size_t>(i)]; }
+
+    /**
+     * Determine size to allocate for all planes. Optionally retrieves the per-plane sizes in
+     * planeSizes if not null. If total size overflows will return SIZE_MAX and set all planeSizes
+     * to SIZE_MAX. Returns 0 and fills planesSizes with 0 if this SkYUVAPixmapInfo is not valid.
+     */
+    size_t computeTotalBytes(size_t planeSizes[kMaxPlanes] = nullptr) const;
+
+    /**
+     * Takes an allocation that is assumed to be at least computeTotalBytes() in size and configures
+     * the first numPlanes() entries in pixmaps array to point into that memory. The remaining
+     * entries of pixmaps are default initialized. Fails if this SkYUVAPixmapInfo not valid.
+     */
+    bool initPixmapsFromSingleAllocation(void* memory, SkPixmap pixmaps[kMaxPlanes]) const;
+
+    /**
+     * Returns true if this has been configured with a non-empty dimensioned SkYUVAInfo with
+     * compatible color types and row bytes.
+     */
+    bool isValid() const { return fYUVAInfo.isValid(); }
+
+    /** Is this valid and does it use color types allowed by the passed SupportedDataTypes? */
+    bool isSupported(const SupportedDataTypes&) const;
+
+private:
+    SkYUVAInfo fYUVAInfo;
+    std::array<SkImageInfo, kMaxPlanes> fPlaneInfos = {};
+    std::array<size_t, kMaxPlanes> fRowBytes = {};
+    DataType fDataType = DataType::kUnorm8;
+    static_assert(kUnknown_SkColorType == 0, "default init isn't kUnknown");
+};
+
+/**
+ * Helper to store SkPixmap planes as described by a SkYUVAPixmapInfo. Can be responsible for
+ * allocating/freeing memory for pixmaps or use external memory.
+ */
+class SK_API SkYUVAPixmaps {
+public:
+    using DataType = SkYUVAPixmapInfo::DataType;
+    static constexpr auto kMaxPlanes = SkYUVAPixmapInfo::kMaxPlanes;
+
+    static SkColorType RecommendedRGBAColorType(DataType);
+
+    /** Allocate space for pixmaps' pixels in the SkYUVAPixmaps. */
+    static SkYUVAPixmaps Allocate(const SkYUVAPixmapInfo& yuvaPixmapInfo);
+
+    /**
+     * Use storage in SkData as backing store for pixmaps' pixels. SkData is retained by the
+     * SkYUVAPixmaps.
+     */
+    static SkYUVAPixmaps FromData(const SkYUVAPixmapInfo&, sk_sp<SkData>);
+
+    /**
+     * Makes a deep copy of the src SkYUVAPixmaps. The returned SkYUVAPixmaps owns its planes'
+     * backing stores.
+     */
+    static SkYUVAPixmaps MakeCopy(const SkYUVAPixmaps& src);
+
+    /**
+     * Use passed in memory as backing store for pixmaps' pixels. Caller must ensure memory remains
+     * allocated while pixmaps are in use. There must be at least
+     * SkYUVAPixmapInfo::computeTotalBytes() allocated starting at memory.
+     */
+    static SkYUVAPixmaps FromExternalMemory(const SkYUVAPixmapInfo&, void* memory);
+
+    /**
+     * Wraps existing SkPixmaps. The SkYUVAPixmaps will have no ownership of the SkPixmaps' pixel
+     * memory so the caller must ensure it remains valid. Will return an invalid SkYUVAPixmaps if
+     * the SkYUVAInfo isn't compatible with the SkPixmap array (number of planes, plane dimensions,
+     * sufficient color channels in planes, ...).
+     */
+    static SkYUVAPixmaps FromExternalPixmaps(const SkYUVAInfo&, const SkPixmap[kMaxPlanes]);
+
+    /** Default SkYUVAPixmaps is invalid. */
+    SkYUVAPixmaps() = default;
+    ~SkYUVAPixmaps() = default;
+
+    SkYUVAPixmaps(SkYUVAPixmaps&& that) = default;
+    SkYUVAPixmaps& operator=(SkYUVAPixmaps&& that) = default;
+    SkYUVAPixmaps(const SkYUVAPixmaps&) = default;
+    SkYUVAPixmaps& operator=(const SkYUVAPixmaps& that) = default;
+
+    /** Does have initialized pixmaps compatible with its SkYUVAInfo. */
+    bool isValid() const { return !fYUVAInfo.dimensions().isEmpty(); }
+
+    const SkYUVAInfo& yuvaInfo() const { return fYUVAInfo; }
+
+    DataType dataType() const { return fDataType; }
+
+    SkYUVAPixmapInfo pixmapsInfo() const;
+
+    /** Number of pixmap planes or 0 if this SkYUVAPixmaps is invalid. */
+    int numPlanes() const { return this->isValid() ? fYUVAInfo.numPlanes() : 0; }
+
+    /**
+     * Access the SkPixmap planes. They are default initialized if this is not a valid
+     * SkYUVAPixmaps.
+     */
+    const std::array<SkPixmap, kMaxPlanes>& planes() const { return fPlanes; }
+
+    /**
+     * Get the ith SkPixmap plane. SkPixmap will be default initialized if i >= numPlanes or this
+     * SkYUVAPixmaps is invalid.
+     */
+    const SkPixmap& plane(int i) const { return fPlanes[SkToSizeT(i)]; }
+
+    /**
+     * Computes a YUVALocations representation of the planar layout. The result is guaranteed to be
+     * valid if this->isValid().
+     */
+    SkYUVAInfo::YUVALocations toYUVALocations() const;
+
+    /** Does this SkPixmaps own the backing store of the planes? */
+    bool ownsStorage() const { return SkToBool(fData); }
+
+private:
+    SkYUVAPixmaps(const SkYUVAPixmapInfo&, sk_sp<SkData>);
+    SkYUVAPixmaps(const SkYUVAInfo&, DataType, const SkPixmap[kMaxPlanes]);
+
+    std::array<SkPixmap, kMaxPlanes> fPlanes = {};
+    sk_sp<SkData> fData;
+    SkYUVAInfo fYUVAInfo;
+    DataType fDataType;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+constexpr SkYUVAPixmapInfo::SupportedDataTypes SkYUVAPixmapInfo::SupportedDataTypes::All() {
+    using ULL = unsigned long long; // bitset cons. takes this.
+    ULL bits = 0;
+    for (ULL c = 1; c <= 4; ++c) {
+        for (ULL dt = 0; dt <= ULL(kDataTypeCnt); ++dt) {
+            if (DefaultColorTypeForDataType(static_cast<DataType>(dt),
+                                            static_cast<int>(c)) != kUnknown_SkColorType) {
+                bits |= ULL(1) << (dt + static_cast<ULL>(kDataTypeCnt)*(c - 1));
+            }
+        }
+    }
+    SupportedDataTypes combinations;
+    combinations.fDataTypeSupport = bits;
+    return combinations;
+}
+
+constexpr bool SkYUVAPixmapInfo::SupportedDataTypes::supported(PlaneConfig config,
+                                                               DataType type) const {
+    int n = SkYUVAInfo::NumPlanes(config);
+    for (int i = 0; i < n; ++i) {
+        auto c = static_cast<size_t>(SkYUVAInfo::NumChannelsInPlane(config, i));
+        SkASSERT(c >= 1 && c <= 4);
+        if (!fDataTypeSupport[static_cast<size_t>(type) +
+                              (c - 1)*static_cast<size_t>(kDataTypeCnt)]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+constexpr SkColorType SkYUVAPixmapInfo::DefaultColorTypeForDataType(DataType dataType,
+                                                                    int numChannels) {
+    switch (numChannels) {
+        case 1:
+            switch (dataType) {
+                case DataType::kUnorm8:         return kGray_8_SkColorType;
+                case DataType::kUnorm16:        return kA16_unorm_SkColorType;
+                case DataType::kFloat16:        return kA16_float_SkColorType;
+                case DataType::kUnorm10_Unorm2: return kUnknown_SkColorType;
+            }
+            break;
+        case 2:
+            switch (dataType) {
+                case DataType::kUnorm8:         return kR8G8_unorm_SkColorType;
+                case DataType::kUnorm16:        return kR16G16_unorm_SkColorType;
+                case DataType::kFloat16:        return kR16G16_float_SkColorType;
+                case DataType::kUnorm10_Unorm2: return kUnknown_SkColorType;
+            }
+            break;
+        case 3:
+            // None of these are tightly packed. The intended use case is for interleaved YUVA
+            // planes where we're forcing opaqueness by ignoring the alpha values.
+            // There are "x" rather than "A" variants for Unorm8 and Unorm10_Unorm2 but we don't
+            // choose them because 1) there is no inherent advantage and 2) there is better support
+            // in the GPU backend for the "A" versions.
+            switch (dataType) {
+                case DataType::kUnorm8:         return kRGBA_8888_SkColorType;
+                case DataType::kUnorm16:        return kR16G16B16A16_unorm_SkColorType;
+                case DataType::kFloat16:        return kRGBA_F16_SkColorType;
+                case DataType::kUnorm10_Unorm2: return kRGBA_1010102_SkColorType;
+            }
+            break;
+        case 4:
+            switch (dataType) {
+                case DataType::kUnorm8:         return kRGBA_8888_SkColorType;
+                case DataType::kUnorm16:        return kR16G16B16A16_unorm_SkColorType;
+                case DataType::kFloat16:        return kRGBA_F16_SkColorType;
+                case DataType::kUnorm10_Unorm2: return kRGBA_1010102_SkColorType;
+            }
+            break;
+    }
+    return kUnknown_SkColorType;
+}
+
+#endif

package/cpp/skia/include/docs/SkPDFDocument.h

@@ -0,0 +1,196 @@
+// Copyright 2018 Google LLC.
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+#ifndef SkPDFDocument_DEFINED
+#define SkPDFDocument_DEFINED
+
+#include "include/core/SkDocument.h"
+
+#include <vector>
+
+#include "include/core/SkColor.h"
+#include "include/core/SkMilestone.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkString.h"
+#include "include/core/SkTime.h"
+#include "include/private/SkNoncopyable.h"
+
+#define SKPDF_STRING(X) SKPDF_STRING_IMPL(X)
+#define SKPDF_STRING_IMPL(X) #X
+
+class SkExecutor;
+class SkPDFArray;
+class SkPDFTagTree;
+
+namespace SkPDF {
+
+/** Attributes for nodes in the PDF tree. */
+class SK_API AttributeList : SkNoncopyable {
+public:
+    AttributeList();
+    ~AttributeList();
+
+    // Each attribute must have an owner (e.g. "Layout", "List", "Table", etc)
+    // and an attribute name (e.g. "BBox", "RowSpan", etc.) from PDF32000_2008 14.8.5,
+    // and then a value of the proper type according to the spec.
+    void appendInt(const char* owner, const char* name, int value);
+    void appendFloat(const char* owner, const char* name, float value);
+    void appendName(const char* owner, const char* attrName, const char* value);
+    void appendString(const char* owner, const char* attrName, const char* value);
+    void appendFloatArray(const char* owner,
+                          const char* name,
+                          const std::vector<float>& value);
+    // Deprecated.
+    void appendStringArray(const char* owner,
+                           const char* attrName,
+                           const std::vector<SkString>& values);
+    void appendNodeIdArray(const char* owner,
+                           const char* attrName,
+                           const std::vector<int>& nodeIds);
+
+private:
+    friend class ::SkPDFTagTree;
+
+    std::unique_ptr<SkPDFArray> fAttrs;
+};
+
+/** A node in a PDF structure tree, giving a semantic representation
+    of the content.  Each node ID is associated with content
+    by passing the SkCanvas and node ID to SkPDF::SetNodeId() when drawing.
+    NodeIDs should be unique within each tree.
+*/
+struct StructureElementNode {
+    SkString fTypeString;
+    std::vector<std::unique_ptr<StructureElementNode>> fChildVector;
+    int fNodeId = 0;
+    std::vector<int> fAdditionalNodeIds;
+    AttributeList fAttributes;
+    SkString fAlt;
+    SkString fLang;
+};
+
+/** Optional metadata to be passed into the PDF factory function.
+*/
+struct Metadata {
+    /** The document's title.
+    */
+    SkString fTitle;
+
+    /** The name of the person who created the document.
+    */
+    SkString fAuthor;
+
+    /** The subject of the document.
+    */
+    SkString fSubject;
+
+    /** Keywords associated with the document.  Commas may be used to delineate
+        keywords within the string.
+    */
+    SkString fKeywords;
+
+    /** If the document was converted to PDF from another format,
+        the name of the conforming product that created the
+        original document from which it was converted.
+    */
+    SkString fCreator;
+
+    /** The product that is converting this document to PDF.
+    */
+    SkString fProducer = SkString("Skia/PDF m" SKPDF_STRING(SK_MILESTONE));
+
+    /** The date and time the document was created.
+        The zero default value represents an unknown/unset time.
+    */
+    SkTime::DateTime fCreation = {0, 0, 0, 0, 0, 0, 0, 0};
+
+    /** The date and time the document was most recently modified.
+        The zero default value represents an unknown/unset time.
+    */
+    SkTime::DateTime fModified = {0, 0, 0, 0, 0, 0, 0, 0};
+
+    /** The DPI (pixels-per-inch) at which features without native PDF support
+        will be rasterized (e.g. draw image with perspective, draw text with
+        perspective, ...)  A larger DPI would create a PDF that reflects the
+        original intent with better fidelity, but it can make for larger PDF
+        files too, which would use more memory while rendering, and it would be
+        slower to be processed or sent online or to printer.
+    */
+    SkScalar fRasterDPI = SK_ScalarDefaultRasterDPI;
+
+    /** If true, include XMP metadata, a document UUID, and sRGB output intent
+        information.  This adds length to the document and makes it
+        non-reproducable, but are necessary features for PDF/A-2b conformance
+    */
+    bool fPDFA = false;
+
+    /** Encoding quality controls the trade-off between size and quality. By
+        default this is set to 101 percent, which corresponds to lossless
+        encoding. If this value is set to a value <= 100, and the image is
+        opaque, it will be encoded (using JPEG) with that quality setting.
+    */
+    int fEncodingQuality = 101;
+
+    /** An optional tree of structured document tags that provide
+        a semantic representation of the content. The caller
+        should retain ownership.
+    */
+    StructureElementNode* fStructureElementTreeRoot = nullptr;
+
+    /** Executor to handle threaded work within PDF Backend. If this is nullptr,
+        then all work will be done serially on the main thread. To have worker
+        threads assist with various tasks, set this to a valid SkExecutor
+        instance. Currently used for executing Deflate algorithm in parallel.
+
+        If set, the PDF output will be non-reproducible in the order and
+        internal numbering of objects, but should render the same.
+
+        Experimental.
+    */
+    SkExecutor* fExecutor = nullptr;
+
+    /** Preferred Subsetter. Only respected if both are compiled in.
+
+        The Sfntly subsetter is deprecated.
+
+        Experimental.
+    */
+    enum Subsetter {
+        kHarfbuzz_Subsetter,
+        kSfntly_Subsetter,
+    } fSubsetter = kHarfbuzz_Subsetter;
+};
+
+/** Associate a node ID with subsequent drawing commands in an
+    SkCanvas.  The same node ID can appear in a StructureElementNode
+    in order to associate a document's structure element tree with
+    its content.
+
+    A node ID of zero indicates no node ID.
+
+    @param canvas  The canvas used to draw to the PDF.
+    @param nodeId  The node ID for subsequent drawing commands.
+*/
+SK_API void SetNodeId(SkCanvas* dst, int nodeID);
+
+/** Create a PDF-backed document, writing the results into a SkWStream.
+
+    PDF pages are sized in point units. 1 pt == 1/72 inch == 127/360 mm.
+
+    @param stream A PDF document will be written to this stream.  The document may write
+           to the stream at anytime during its lifetime, until either close() is
+           called or the document is deleted.
+    @param metadata a PDFmetadata object.  Any fields may be left empty.
+
+    @returns NULL if there is an error, otherwise a newly created PDF-backed SkDocument.
+*/
+SK_API sk_sp<SkDocument> MakeDocument(SkWStream* stream, const Metadata& metadata);
+
+static inline sk_sp<SkDocument> MakeDocument(SkWStream* stream) {
+    return MakeDocument(stream, Metadata());
+}
+
+}  // namespace SkPDF
+
+#undef SKPDF_STRING
+#undef SKPDF_STRING_IMPL
+#endif  // SkPDFDocument_DEFINED

package/cpp/skia/include/docs/SkXPSDocument.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkXPSDocument_DEFINED
+#define SkXPSDocument_DEFINED
+
+#include "include/core/SkTypes.h"
+
+#ifdef SK_BUILD_FOR_WIN
+
+#include "include/core/SkDocument.h"
+
+struct IXpsOMObjectFactory;
+
+namespace SkXPS {
+
+SK_API sk_sp<SkDocument> MakeDocument(SkWStream* stream,
+                                      IXpsOMObjectFactory* xpsFactory,
+                                      SkScalar dpi = SK_ScalarDefaultRasterDPI);
+
+}  // namespace SkXPS
+#endif  // SK_BUILD_FOR_WIN
+#endif  // SkXPSDocument_DEFINED

package/cpp/skia/include/effects/Sk1DPathEffect.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2006 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef Sk1DPathEffect_DEFINED
+#define Sk1DPathEffect_DEFINED
+
+#include "include/core/SkPathEffect.h"
+
+class SK_API SkPath1DPathEffect {
+public:
+    enum Style {
+        kTranslate_Style,   // translate the shape to each position
+        kRotate_Style,      // rotate the shape about its center
+        kMorph_Style,       // transform each point, and turn lines into curves
+
+        kLastEnum_Style = kMorph_Style,
+    };
+
+    /** Dash by replicating the specified path.
+        @param path The path to replicate (dash)
+        @param advance The space between instances of path
+        @param phase distance (mod advance) along path for its initial position
+        @param style how to transform path at each point (based on the current
+                     position and tangent)
+    */
+    static sk_sp<SkPathEffect> Make(const SkPath& path, SkScalar advance, SkScalar phase, Style);
+
+    static void RegisterFlattenables();
+};
+
+#endif

package/cpp/skia/include/effects/Sk2DPathEffect.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2006 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef Sk2DPathEffect_DEFINED
+#define Sk2DPathEffect_DEFINED
+
+#include "include/core/SkPathEffect.h"
+
+class SkMatrix;
+class SkPath;
+
+class SK_API SkLine2DPathEffect {
+public:
+    static sk_sp<SkPathEffect> Make(SkScalar width, const SkMatrix& matrix);
+
+    static void RegisterFlattenables();
+};
+
+class SK_API SkPath2DPathEffect {
+public:
+    static sk_sp<SkPathEffect> Make(const SkMatrix& matrix, const SkPath& path);
+
+    static void RegisterFlattenables();
+};
+
+#endif

package/cpp/skia/include/effects/SkBlenders.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkBlenders_DEFINED
+#define SkBlenders_DEFINED
+
+#include "include/core/SkBlender.h"
+
+class SK_API SkBlenders {
+public:
+    /**
+     *  Create a blender that implements the following:
+     *     k1 * src * dst + k2 * src + k3 * dst + k4
+     *  @param k1, k2, k3, k4 The four coefficients.
+     *  @param enforcePMColor If true, the RGB channels will be clamped to the calculated alpha.
+     */
+    static sk_sp<SkBlender> Arithmetic(float k1, float k2, float k3, float k4, bool enforcePremul);
+
+private:
+    SkBlenders() = delete;
+};
+
+#endif

package/cpp/skia/include/effects/SkBlurDrawLooper.h

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2008 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkBlurDrawLooper_DEFINED
+#define SkBlurDrawLooper_DEFINED
+
+#include "include/core/SkDrawLooper.h"
+
+#ifndef SK_SUPPORT_LEGACY_DRAWLOOPER
+#error "SkDrawLooper is unsupported"
+#endif
+
+/**
+ *  DEPRECATED: No longer supported in Skia.
+ */
+namespace SkBlurDrawLooper {
+    sk_sp<SkDrawLooper> SK_API Make(SkColor4f color, SkColorSpace* cs,
+            SkScalar sigma, SkScalar dx, SkScalar dy);
+    sk_sp<SkDrawLooper> SK_API Make(SkColor color, SkScalar sigma, SkScalar dx, SkScalar dy);
+}  // namespace SkBlurDrawLooper
+
+#endif