rngine 0.7.2 → 0.8.1

package/shared/skia/modules/svg/include/SkSVGPattern.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2017 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSVGPattern_DEFINED
+#define SkSVGPattern_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+#include "modules/svg/include/SkSVGHiddenContainer.h"
+#include "modules/svg/include/SkSVGNode.h"
+#include "modules/svg/include/SkSVGTypes.h"
+
+#include <optional>
+
+class SkPaint;
+class SkSVGRenderContext;
+
+class SK_API SkSVGPattern final : public SkSVGHiddenContainer {
+public:
+    static sk_sp<SkSVGPattern> Make() {
+        return sk_sp<SkSVGPattern>(new SkSVGPattern());
+    }
+
+    SVG_ATTR(Href, SkSVGIRI, SkSVGIRI())
+    SVG_OPTIONAL_ATTR(X               , SkSVGLength)
+    SVG_OPTIONAL_ATTR(Y               , SkSVGLength)
+    SVG_OPTIONAL_ATTR(Width           , SkSVGLength)
+    SVG_OPTIONAL_ATTR(Height          , SkSVGLength)
+    SVG_OPTIONAL_ATTR(PatternTransform, SkSVGTransformType)
+
+protected:
+    SkSVGPattern();
+
+    bool parseAndSetAttribute(const char*, const char*) override;
+
+    bool onAsPaint(const SkSVGRenderContext&, SkPaint*) const override;
+
+private:
+    struct PatternAttributes {
+        std::optional<SkSVGLength>  fX,
+                                    fY,
+                                    fWidth,
+                                    fHeight;
+        std::optional<SkSVGTransformType> fPatternTransform;
+    };
+
+    const SkSVGPattern* resolveHref(const SkSVGRenderContext&, PatternAttributes*) const;
+    const SkSVGPattern* hrefTarget(const SkSVGRenderContext&) const;
+
+    // TODO:
+    //   - patternUnits
+    //   - patternContentUnits
+
+    using INHERITED = SkSVGHiddenContainer;
+};
+
+#endif // SkSVGPattern_DEFINED

package/shared/skia/modules/svg/include/SkSVGPoly.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSVGPoly_DEFINED
+#define SkSVGPoly_DEFINED
+
+#include "include/core/SkPath.h"
+#include "include/core/SkPathTypes.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+#include "modules/svg/include/SkSVGNode.h"
+#include "modules/svg/include/SkSVGShape.h"
+#include "modules/svg/include/SkSVGTypes.h"
+
+class SkCanvas;
+class SkPaint;
+class SkSVGLengthContext;
+class SkSVGRenderContext;
+
+// Handles <polygon> and <polyline> elements.
+class SK_API SkSVGPoly final : public SkSVGShape {
+public:
+    static sk_sp<SkSVGPoly> MakePolygon() {
+        return sk_sp<SkSVGPoly>(new SkSVGPoly(SkSVGTag::kPolygon));
+    }
+
+    static sk_sp<SkSVGPoly> MakePolyline() {
+        return sk_sp<SkSVGPoly>(new SkSVGPoly(SkSVGTag::kPolyline));
+    }
+
+    SVG_ATTR(Points, SkSVGPointsType, SkSVGPointsType())
+
+protected:
+    bool parseAndSetAttribute(const char*, const char*) override;
+
+    void onDraw(SkCanvas*, const SkSVGLengthContext&, const SkPaint&,
+                SkPathFillType) const override;
+
+    SkPath onAsPath(const SkSVGRenderContext&) const override;
+
+    SkRect onTransformableObjectBoundingBox(const SkSVGRenderContext&) const override;
+
+private:
+    explicit SkSVGPoly(SkSVGTag);
+
+    mutable SkPath fPath;  // mutated in onDraw(), to apply inherited fill types.
+
+    using INHERITED = SkSVGShape;
+};
+
+#endif // SkSVGPoly_DEFINED

package/shared/skia/modules/svg/include/SkSVGRadialGradient.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2017 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSVGRadialGradient_DEFINED
+#define SkSVGRadialGradient_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/private/SkAPI.h"
+#include "modules/svg/include/SkSVGGradient.h"
+#include "modules/svg/include/SkSVGNode.h"
+#include "modules/svg/include/SkSVGTypes.h"
+
+class SkMatrix;
+class SkSVGRenderContext;
+class SkShader;
+enum class SkTileMode;
+
+class SK_API SkSVGRadialGradient final : public SkSVGGradient {
+public:
+    static sk_sp<SkSVGRadialGradient> Make() {
+        return sk_sp<SkSVGRadialGradient>(new SkSVGRadialGradient());
+    }
+
+    SVG_ATTR(Cx, SkSVGLength, SkSVGLength(50, SkSVGLength::Unit::kPercentage))
+    SVG_ATTR(Cy, SkSVGLength, SkSVGLength(50, SkSVGLength::Unit::kPercentage))
+    SVG_ATTR(R,  SkSVGLength, SkSVGLength(50, SkSVGLength::Unit::kPercentage))
+    SVG_OPTIONAL_ATTR(Fx, SkSVGLength)
+    SVG_OPTIONAL_ATTR(Fy, SkSVGLength)
+
+protected:
+    bool parseAndSetAttribute(const char*, const char*) override;
+
+    sk_sp<SkShader> onMakeShader(const SkSVGRenderContext&,
+                                 const SkColor4f*, const SkScalar*, int count,
+                                 SkTileMode, const SkMatrix&) const override;
+private:
+    SkSVGRadialGradient();
+
+    using INHERITED = SkSVGGradient;
+};
+
+#endif // SkSVGRadialGradient_DEFINED

package/shared/skia/modules/svg/include/SkSVGRect.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSVGRect_DEFINED
+#define SkSVGRect_DEFINED
+
+#include "include/core/SkPath.h"
+#include "include/core/SkPathTypes.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+#include "modules/svg/include/SkSVGNode.h"
+#include "modules/svg/include/SkSVGShape.h"
+#include "modules/svg/include/SkSVGTypes.h"
+
+class SkCanvas;
+class SkPaint;
+class SkRRect;
+class SkSVGLengthContext;
+class SkSVGRenderContext;
+
+class SK_API SkSVGRect final : public SkSVGShape {
+public:
+    static sk_sp<SkSVGRect> Make() { return sk_sp<SkSVGRect>(new SkSVGRect()); }
+
+    SVG_ATTR(X     , SkSVGLength, SkSVGLength(0))
+    SVG_ATTR(Y     , SkSVGLength, SkSVGLength(0))
+    SVG_ATTR(Width , SkSVGLength, SkSVGLength(0))
+    SVG_ATTR(Height, SkSVGLength, SkSVGLength(0))
+
+    SVG_OPTIONAL_ATTR(Rx, SkSVGLength)
+    SVG_OPTIONAL_ATTR(Ry, SkSVGLength)
+
+protected:
+    bool parseAndSetAttribute(const char*, const char*) override;
+
+    void onDraw(SkCanvas*, const SkSVGLengthContext&, const SkPaint&,
+                SkPathFillType) const override;
+
+    SkPath onAsPath(const SkSVGRenderContext&) const override;
+
+    SkRect onTransformableObjectBoundingBox(const SkSVGRenderContext&) const override;
+
+private:
+    SkSVGRect();
+
+    SkRRect resolve(const SkSVGLengthContext&) const;
+
+    using INHERITED = SkSVGShape;
+};
+
+#endif // SkSVGRect_DEFINED

package/shared/skia/modules/svg/include/SkSVGRenderContext.h

@@ -0,0 +1,229 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSVGRenderContext_DEFINED
+#define SkSVGRenderContext_DEFINED
+
+#include "include/core/SkFontMgr.h"
+#include "include/core/SkFourByteTag.h"
+#include "include/core/SkM44.h"
+#include "include/core/SkPath.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkSize.h"
+#include "include/core/SkTypes.h"
+#include "modules/skshaper/include/SkShaper.h"
+#include "modules/skshaper/include/SkShaper_factory.h"
+#include "modules/svg/include/SkSVGAttribute.h"
+#include "modules/svg/include/SkSVGIDMapper.h"
+#include "modules/svg/include/SkSVGNode.h"
+#include "modules/svg/include/SkSVGTypes.h"
+#include "src/core/SkTHash.h"
+#include "src/core/SkTLazy.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <utility>
+
+class SkCanvas;
+class SkPaint;
+class SkString;
+namespace skresources { class ResourceProvider; }
+
+class SK_API SkSVGLengthContext {
+public:
+    SkSVGLengthContext(const SkSize& viewport, SkScalar dpi = 90)
+        : fViewport(viewport), fDPI(dpi) {}
+
+    enum class LengthType {
+        kHorizontal,
+        kVertical,
+        kOther,
+    };
+
+    const SkSize& viewPort() const { return fViewport; }
+    void setViewPort(const SkSize& viewport) { fViewport = viewport; }
+
+    SkScalar resolve(const SkSVGLength&, LengthType) const;
+    SkRect   resolveRect(const SkSVGLength& x, const SkSVGLength& y,
+                         const SkSVGLength& w, const SkSVGLength& h) const;
+
+private:
+    SkSize   fViewport;
+    SkScalar fDPI;
+};
+
+struct SK_API SkSVGPresentationContext {
+    SkSVGPresentationContext();
+    SkSVGPresentationContext(const SkSVGPresentationContext&)            = default;
+    SkSVGPresentationContext& operator=(const SkSVGPresentationContext&) = default;
+
+    const skia_private::THashMap<SkString, SkSVGColorType>* fNamedColors = nullptr;
+
+    // Inherited presentation attributes, computed for the current node.
+    SkSVGPresentationAttributes fInherited;
+};
+
+class SK_API SkSVGRenderContext {
+public:
+    // Captures data required for object bounding box resolution.
+    struct OBBScope {
+        const SkSVGNode*          fNode;
+        const SkSVGRenderContext* fCtx;
+    };
+
+    SkSVGRenderContext(SkCanvas*,
+                       const sk_sp<SkFontMgr>&,
+                       const sk_sp<skresources::ResourceProvider>&,
+                       const SkSVGIDMapper&,
+                       const SkSVGLengthContext&,
+                       const SkSVGPresentationContext&,
+                       const OBBScope&,
+                       const sk_sp<SkShapers::Factory>&);
+    SkSVGRenderContext(const SkSVGRenderContext&);
+    SkSVGRenderContext(const SkSVGRenderContext&, SkCanvas*);
+    // Establish a new OBB scope.  Normally used when entering a node's render scope.
+    SkSVGRenderContext(const SkSVGRenderContext&, const SkSVGNode*);
+    ~SkSVGRenderContext();
+
+    const SkSVGLengthContext& lengthContext() const { return *fLengthContext; }
+    SkSVGLengthContext* writableLengthContext() { return fLengthContext.writable(); }
+
+    const SkSVGPresentationContext& presentationContext() const { return *fPresentationContext; }
+
+    SkCanvas* canvas() const { return fCanvas; }
+    void saveOnce();
+
+    enum ApplyFlags {
+        kLeaf = 1 << 0, // the target node doesn't have descendants
+    };
+    void applyPresentationAttributes(const SkSVGPresentationAttributes&, uint32_t flags);
+
+    // Scoped wrapper that temporarily clears the original node reference.
+    class BorrowedNode {
+    public:
+        explicit BorrowedNode(sk_sp<SkSVGNode>* node)
+            : fOwner(node) {
+            if (fOwner) {
+                fBorrowed = std::move(*fOwner);
+                *fOwner = nullptr;
+            }
+        }
+
+        ~BorrowedNode() {
+            if (fOwner) {
+                *fOwner = std::move(fBorrowed);
+            }
+        }
+
+        const SkSVGNode* get() const { return fBorrowed.get(); }
+        const SkSVGNode* operator->() const { return fBorrowed.get(); }
+        const SkSVGNode& operator*() const { return *fBorrowed; }
+
+        explicit operator bool() const { return !!fBorrowed; }
+
+    private:
+        // noncopyable
+        BorrowedNode(const BorrowedNode&)      = delete;
+        BorrowedNode& operator=(BorrowedNode&) = delete;
+
+        sk_sp<SkSVGNode>* fOwner;
+        sk_sp<SkSVGNode>  fBorrowed;
+    };
+
+    // Note: the id->node association is cleared for the lifetime of the returned value
+    // (effectively breaks reference cycles, assuming appropriate return value scoping).
+    BorrowedNode findNodeById(const SkSVGIRI&) const;
+
+    std::optional<SkPaint> fillPaint() const;
+    std::optional<SkPaint> strokePaint() const;
+
+    SkSVGColorType resolveSvgColor(const SkSVGColor&) const;
+
+    // The local computed clip path (not inherited).
+    const SkPath* clipPath() const { return SkOptAddressOrNull(fClipPath); }
+
+    const sk_sp<skresources::ResourceProvider>& resourceProvider() const {
+        return fResourceProvider;
+    }
+
+    sk_sp<SkFontMgr> fontMgr() const {
+        // It is probably an oversight to try to render <text> without having set the SkFontMgr.
+        // We will assert this in debug mode, but fallback to an empty fontmgr in release builds.
+        SkASSERT(fFontMgr);
+        return fFontMgr ? fFontMgr : SkFontMgr::RefEmpty();
+    }
+
+    // Returns the translate/scale transformation required to map into the current OBB scope,
+    // with the specified units.
+    struct OBBTransform {
+        SkV2 offset, scale;
+    };
+    OBBTransform transformForCurrentOBB(SkSVGObjectBoundingBoxUnits) const;
+
+    SkRect resolveOBBRect(const SkSVGLength& x, const SkSVGLength& y,
+                          const SkSVGLength& w, const SkSVGLength& h,
+                          SkSVGObjectBoundingBoxUnits) const;
+
+    const OBBScope& currentOBBScope() const { return fOBBScope; }
+
+    std::unique_ptr<SkShaper> makeShaper() const {
+        SkASSERT(fTextShapingFactory);
+        return fTextShapingFactory->makeShaper(this->fontMgr());
+    }
+
+    std::unique_ptr<SkShaper::BiDiRunIterator> makeBidiRunIterator(const char* utf8,
+                                                                   size_t utf8Bytes,
+                                                                   uint8_t bidiLevel) const {
+        SkASSERT(fTextShapingFactory);
+        return fTextShapingFactory->makeBidiRunIterator(utf8, utf8Bytes, bidiLevel);
+    }
+
+    std::unique_ptr<SkShaper::ScriptRunIterator> makeScriptRunIterator(const char* utf8,
+                                                                       size_t utf8Bytes) const {
+        SkASSERT(fTextShapingFactory);
+        constexpr SkFourByteTag unknownScript = SkSetFourByteTag('Z', 'z', 'z', 'z');
+        return fTextShapingFactory->makeScriptRunIterator(utf8, utf8Bytes, unknownScript);
+    }
+
+private:
+    // Stack-only
+    void* operator new(size_t)                               = delete;
+    void* operator new(size_t, void*)                        = delete;
+    SkSVGRenderContext& operator=(const SkSVGRenderContext&) = delete;
+
+    void applyOpacity(SkScalar opacity, uint32_t flags, bool hasFilter);
+    void applyFilter(const SkSVGFuncIRI&);
+    void applyClip(const SkSVGFuncIRI&);
+    void applyMask(const SkSVGFuncIRI&);
+
+    std::optional<SkPaint> commonPaint(const SkSVGPaint&, float opacity) const;
+
+    const sk_sp<SkFontMgr>&                       fFontMgr;
+    const sk_sp<SkShapers::Factory>&              fTextShapingFactory;
+    const sk_sp<skresources::ResourceProvider>&   fResourceProvider;
+    const SkSVGIDMapper&                          fIDMapper;
+    SkTCopyOnFirstWrite<SkSVGLengthContext>       fLengthContext;
+    SkTCopyOnFirstWrite<SkSVGPresentationContext> fPresentationContext;
+    SkCanvas*                                     fCanvas;
+    // The save count on 'fCanvas' at construction time.
+    // A restoreToCount() will be issued on destruction.
+    int                                           fCanvasSaveCount;
+
+    // clipPath, if present for the current context (not inherited).
+    std::optional<SkPath>                         fClipPath;
+
+    // Deferred opacity optimization for leaf nodes.
+    float                                         fDeferredPaintOpacity = 1;
+
+    // Current object bounding box scope.
+    const OBBScope                                fOBBScope;
+};
+
+#endif // SkSVGRenderContext_DEFINED

package/shared/skia/modules/svg/include/SkSVGSVG.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSVGSVG_DEFINED
+#define SkSVGSVG_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSize.h"
+#include "include/private/SkAPI.h"
+#include "modules/svg/include/SkSVGContainer.h"
+#include "modules/svg/include/SkSVGNode.h"
+#include "modules/svg/include/SkSVGTypes.h"
+#include "modules/svg/include/SkSVGValue.h"
+
+class SkSVGLengthContext;
+class SkSVGRenderContext;
+enum class SkSVGAttribute;
+
+class SK_API SkSVGSVG : public SkSVGContainer {
+public:
+    enum class Type {
+        kRoot,
+        kInner,
+    };
+    static sk_sp<SkSVGSVG> Make(Type t = Type::kInner) { return sk_sp<SkSVGSVG>(new SkSVGSVG(t)); }
+
+    SVG_ATTR(X                  , SkSVGLength, SkSVGLength(0))
+    SVG_ATTR(Y                  , SkSVGLength, SkSVGLength(0))
+    SVG_ATTR(Width              , SkSVGLength, SkSVGLength(100, SkSVGLength::Unit::kPercentage))
+    SVG_ATTR(Height             , SkSVGLength, SkSVGLength(100, SkSVGLength::Unit::kPercentage))
+    SVG_ATTR(PreserveAspectRatio, SkSVGPreserveAspectRatio, SkSVGPreserveAspectRatio())
+
+    SVG_OPTIONAL_ATTR(ViewBox, SkSVGViewBoxType)
+
+    SkSize intrinsicSize(const SkSVGLengthContext&) const;
+
+    void renderNode(const SkSVGRenderContext&, const SkSVGIRI& iri) const;
+
+protected:
+    bool onPrepareToRender(SkSVGRenderContext*) const override;
+
+    void onSetAttribute(SkSVGAttribute, const SkSVGValue&) override;
+
+private:
+    explicit SkSVGSVG(Type t)
+        : INHERITED(SkSVGTag::kSvg)
+        , fType(t)
+    {}
+
+    // Some attributes behave differently for the outermost svg element.
+    const Type fType;
+
+    using INHERITED = SkSVGContainer;
+};
+
+#endif // SkSVGSVG_DEFINED

package/shared/skia/modules/svg/include/SkSVGShape.h

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSVGShape_DEFINED
+#define SkSVGShape_DEFINED
+
+#include "include/core/SkPathTypes.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+#include "modules/svg/include/SkSVGTransformableNode.h"
+
+class SkCanvas;
+class SkPaint;
+class SkSVGLengthContext;
+class SkSVGNode;
+class SkSVGRenderContext;
+enum class SkSVGTag;
+
+class SK_API SkSVGShape : public SkSVGTransformableNode {
+public:
+    void appendChild(sk_sp<SkSVGNode>) override;
+
+protected:
+    explicit SkSVGShape(SkSVGTag);
+
+    void onRender(const SkSVGRenderContext&) const final;
+
+    virtual void onDraw(SkCanvas*, const SkSVGLengthContext&, const SkPaint&,
+                        SkPathFillType) const = 0;
+
+private:
+    using INHERITED = SkSVGTransformableNode;
+};
+
+#endif // SkSVGShape_DEFINED

package/shared/skia/modules/svg/include/SkSVGStop.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSVGStop_DEFINED
+#define SkSVGStop_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+#include "modules/svg/include/SkSVGHiddenContainer.h"
+#include "modules/svg/include/SkSVGNode.h"
+#include "modules/svg/include/SkSVGTypes.h"
+
+class SK_API SkSVGStop : public SkSVGHiddenContainer {
+public:
+    static constexpr SkSVGTag tag = SkSVGTag::kStop;
+
+    static sk_sp<SkSVGStop> Make() {
+        return sk_sp<SkSVGStop>(new SkSVGStop());
+    }
+
+    SVG_ATTR(Offset, SkSVGLength, SkSVGLength(0, SkSVGLength::Unit::kPercentage))
+
+protected:
+    bool parseAndSetAttribute(const char*, const char*) override;
+
+private:
+    SkSVGStop();
+
+    using INHERITED = SkSVGHiddenContainer;
+};
+
+#endif // SkSVGStop_DEFINED