1 files changed, 142 insertions, 206 deletions

diff --git a/Source/WebCore/rendering/style/BasicShapes.h b/Source/WebCore/rendering/style/BasicShapes.h
index 36464596a..f44962d9d 100644
--- a/Source/WebCore/rendering/style/BasicShapes.h
+++ b/Source/WebCore/rendering/style/BasicShapes.h
@@ -27,8 +27,7 @@
  * SUCH DAMAGE.
  */
 
-#ifndef BasicShapes_h
-#define BasicShapes_h
+#pragma once
 
 #include "Length.h"
 #include "LengthSize.h"
@@ -36,6 +35,7 @@
 #include "WindRule.h"
 #include <wtf/RefCounted.h>
 #include <wtf/RefPtr.h>
+#include <wtf/TypeCasts.h>
 #include <wtf/Vector.h>
 
 namespace WebCore {
@@ -43,82 +43,29 @@ namespace WebCore {
 class FloatRect;
 class Path;
 class RenderBox;
+class SVGPathByteStream;
 
 class BasicShape : public RefCounted<BasicShape> {
 public:
     virtual ~BasicShape() { }
 
     enum Type {
-        BasicShapeRectangleType,
-        DeprecatedBasicShapeCircleType,
-        DeprecatedBasicShapeEllipseType,
         BasicShapePolygonType,
-        BasicShapeInsetRectangleType,
+        BasicShapePathType,
         BasicShapeCircleType,
         BasicShapeEllipseType,
         BasicShapeInsetType
     };
 
-    bool canBlend(const BasicShape*) const;
-
-    virtual void path(Path&, const FloatRect&) = 0;
-    virtual WindRule windRule() const { return RULE_NONZERO; }
-    virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const = 0;
-
     virtual Type type() const = 0;
 
-    LayoutBox layoutBox() const { return m_layoutBox; }
-    void setLayoutBox(LayoutBox layoutBox) { m_layoutBox = layoutBox; }
-
-protected:
-    BasicShape()
-        : m_layoutBox(BoxMissing)
-    {
-    }
-
-private:
-    LayoutBox m_layoutBox;
-};
-
-class BasicShapeRectangle : public BasicShape {
-public:
-    static PassRefPtr<BasicShapeRectangle> create() { return adoptRef(new BasicShapeRectangle); }
-
-    const Length& x() const { return m_x; }
-    const Length& y() const { return m_y; }
-    const Length& width() const { return m_width; }
-    const Length& height() const { return m_height; }
-    const Length& cornerRadiusX() const { return m_cornerRadiusX; }
-    const Length& cornerRadiusY() const { return m_cornerRadiusY; }
-
-    void setX(Length x) { m_x = std::move(x); }
-    void setY(Length y) { m_y = std::move(y); }
-    void setWidth(Length width) { m_width = std::move(width); }
-    void setHeight(Length height) { m_height = std::move(height); }
-    void setCornerRadiusX(Length radiusX)
-    {
-        ASSERT(!radiusX.isUndefined());
-        m_cornerRadiusX = std::move(radiusX);
-    }
-    void setCornerRadiusY(Length radiusY)
-    {
-        ASSERT(!radiusY.isUndefined());
-        m_cornerRadiusY = std::move(radiusY);
-    }
+    virtual const Path& path(const FloatRect&) = 0;
+    virtual WindRule windRule() const { return RULE_NONZERO; }
 
-    virtual void path(Path&, const FloatRect&) override;
-    virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const override;
+    virtual bool canBlend(const BasicShape&) const = 0;
+    virtual Ref<BasicShape> blend(const BasicShape& from, double) const = 0;
 
-    virtual Type type() const override { return BasicShapeRectangleType; }
-private:
-    BasicShapeRectangle() { }
-
-    Length m_y;
-    Length m_x;
-    Length m_width;
-    Length m_height;
-    Length m_cornerRadiusX;
-    Length m_cornerRadiusY;
+    virtual bool operator==(const BasicShape&) const = 0;
 };
 
 class BasicShapeCenterCoordinate {
@@ -153,17 +100,24 @@ public:
     const Length& length() const { return m_length; }
     const Length& computedLength() const { return m_computedLength; }
 
-    BasicShapeCenterCoordinate blend(const BasicShapeCenterCoordinate& other, double progress) const
+    BasicShapeCenterCoordinate blend(const BasicShapeCenterCoordinate& from, double progress) const
     {
-        return BasicShapeCenterCoordinate(TopLeft, m_computedLength.blend(other.m_computedLength, progress));
+        return BasicShapeCenterCoordinate(TopLeft, WebCore::blend(from.m_computedLength, m_computedLength, progress));
+    }
+    
+    bool operator==(const BasicShapeCenterCoordinate& other) const
+    {
+        return m_direction == other.m_direction
+            && m_length == other.m_length
+            && m_computedLength == other.m_computedLength;
     }
 
 private:
+    void updateComputedLength();
+
     Direction m_direction;
     Length m_length;
     Length m_computedLength;
-
-    void updateComputedLength();
 };
 
 class BasicShapeRadius {
@@ -173,10 +127,23 @@ public:
         ClosestSide,
         FarthestSide
     };
-    BasicShapeRadius() : m_value(Undefined), m_type(ClosestSide) { }
-    explicit BasicShapeRadius(Length v) : m_value(v), m_type(Value) { }
-    explicit BasicShapeRadius(Type t) : m_value(Undefined), m_type(t) { }
-    BasicShapeRadius(const BasicShapeRadius& other) : m_value(other.value()), m_type(other.type()) { }
+    BasicShapeRadius()
+        : m_value(Undefined),
+        m_type(ClosestSide)
+    { }
+
+    explicit BasicShapeRadius(Length v)
+        : m_value(v)
+        , m_type(Value)
+    { }
+    explicit BasicShapeRadius(Type t)
+        : m_value(Undefined)
+        , m_type(t)
+    { }
+    BasicShapeRadius(const BasicShapeRadius& other)
+        : m_value(other.value())
+        , m_type(other.type())
+    { }
 
     const Length& value() const { return m_value; }
     Type type() const { return m_type; }
@@ -187,12 +154,17 @@ public:
         return m_type == Value && other.type() == Value;
     }
 
-    BasicShapeRadius blend(const BasicShapeRadius& other, double progress) const
+    BasicShapeRadius blend(const BasicShapeRadius& from, double progress) const
     {
-        if (m_type != Value || other.type() != Value)
-            return BasicShapeRadius(other);
+        if (m_type != Value || from.type() != Value)
+            return BasicShapeRadius(from);
 
-        return BasicShapeRadius(m_value.blend(other.value(), progress));
+        return BasicShapeRadius(WebCore::blend(from.value(), value(), progress));
+    }
+    
+    bool operator==(const BasicShapeRadius& other) const
+    {
+        return m_value == other.m_value && m_type == other.m_type;
     }
 
 private:
@@ -201,58 +173,39 @@ private:
 
 };
 
-class BasicShapeCircle : public BasicShape {
+class BasicShapeCircle final : public BasicShape {
 public:
-    static PassRefPtr<BasicShapeCircle> create() { return adoptRef(new BasicShapeCircle); }
+    static Ref<BasicShapeCircle> create() { return adoptRef(*new BasicShapeCircle); }
 
     const BasicShapeCenterCoordinate& centerX() const { return m_centerX; }
     const BasicShapeCenterCoordinate& centerY() const { return m_centerY; }
     const BasicShapeRadius& radius() const { return m_radius; }
     float floatValueForRadiusInBox(float boxWidth, float boxHeight) const;
 
-    void setCenterX(BasicShapeCenterCoordinate centerX) { m_centerX = std::move(centerX); }
-    void setCenterY(BasicShapeCenterCoordinate centerY) { m_centerY = std::move(centerY); }
-    void setRadius(BasicShapeRadius radius) { m_radius = std::move(radius); }
-
-    virtual void path(Path&, const FloatRect&) override;
-    virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const override;
+    void setCenterX(BasicShapeCenterCoordinate centerX) { m_centerX = WTFMove(centerX); }
+    void setCenterY(BasicShapeCenterCoordinate centerY) { m_centerY = WTFMove(centerY); }
+    void setRadius(BasicShapeRadius radius) { m_radius = WTFMove(radius); }
 
-    virtual Type type() const override { return BasicShapeCircleType; }
 private:
-    BasicShapeCircle() { }
+    BasicShapeCircle() = default;
 
-    BasicShapeCenterCoordinate m_centerX;
-    BasicShapeCenterCoordinate m_centerY;
-    BasicShapeRadius m_radius;
-};
-
-class DeprecatedBasicShapeCircle : public BasicShape {
-public:
-    static PassRefPtr<DeprecatedBasicShapeCircle> create() { return adoptRef(new DeprecatedBasicShapeCircle); }
-
-    const Length& centerX() const { return m_centerX; }
-    const Length& centerY() const { return m_centerY; }
-    const Length& radius() const { return m_radius; }
+    Type type() const override { return BasicShapeCircleType; }
 
-    void setCenterX(Length centerX) { m_centerX = std::move(centerX); }
-    void setCenterY(Length centerY) { m_centerY = std::move(centerY); }
-    void setRadius(Length radius) { m_radius = std::move(radius); }
+    const Path& path(const FloatRect&) override;
 
-    virtual void path(Path&, const FloatRect&) override;
-    virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const override;
+    bool canBlend(const BasicShape&) const override;
+    Ref<BasicShape> blend(const BasicShape& from, double) const override;
 
-    virtual Type type() const override { return DeprecatedBasicShapeCircleType; }
-private:
-    DeprecatedBasicShapeCircle() { }
+    bool operator==(const BasicShape&) const override;
 
-    Length m_centerX;
-    Length m_centerY;
-    Length m_radius;
+    BasicShapeCenterCoordinate m_centerX;
+    BasicShapeCenterCoordinate m_centerY;
+    BasicShapeRadius m_radius;
 };
 
-class BasicShapeEllipse : public BasicShape {
+class BasicShapeEllipse final : public BasicShape {
 public:
-    static PassRefPtr<BasicShapeEllipse> create() { return adoptRef(new BasicShapeEllipse); }
+    static Ref<BasicShapeEllipse> create() { return adoptRef(*new BasicShapeEllipse); }
 
     const BasicShapeCenterCoordinate& centerX() const { return m_centerX; }
     const BasicShapeCenterCoordinate& centerY() const { return m_centerY; }
@@ -260,121 +213,89 @@ public:
     const BasicShapeRadius& radiusY() const { return m_radiusY; }
     float floatValueForRadiusInBox(const BasicShapeRadius&, float center, float boxWidthOrHeight) const;
 
-    void setCenterX(BasicShapeCenterCoordinate centerX) { m_centerX = std::move(centerX); }
-    void setCenterY(BasicShapeCenterCoordinate centerY) { m_centerY = std::move(centerY); }
-    void setRadiusX(BasicShapeRadius radiusX) { m_radiusX = std::move(radiusX); }
-    void setRadiusY(BasicShapeRadius radiusY) { m_radiusY = std::move(radiusY); }
-
-    virtual void path(Path&, const FloatRect&) override;
-    virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const override;
+    void setCenterX(BasicShapeCenterCoordinate centerX) { m_centerX = WTFMove(centerX); }
+    void setCenterY(BasicShapeCenterCoordinate centerY) { m_centerY = WTFMove(centerY); }
+    void setRadiusX(BasicShapeRadius radiusX) { m_radiusX = WTFMove(radiusX); }
+    void setRadiusY(BasicShapeRadius radiusY) { m_radiusY = WTFMove(radiusY); }
 
-    virtual Type type() const override { return BasicShapeEllipseType; }
 private:
-    BasicShapeEllipse() { }
+    BasicShapeEllipse() = default;
 
-    BasicShapeCenterCoordinate m_centerX;
-    BasicShapeCenterCoordinate m_centerY;
-    BasicShapeRadius m_radiusX;
-    BasicShapeRadius m_radiusY;
-};
+    Type type() const override { return BasicShapeEllipseType; }
 
-class DeprecatedBasicShapeEllipse : public BasicShape {
-public:
-    static PassRefPtr<DeprecatedBasicShapeEllipse> create() { return adoptRef(new DeprecatedBasicShapeEllipse); }
+    const Path& path(const FloatRect&) override;
 
-    const Length& centerX() const { return m_centerX; }
-    const Length& centerY() const { return m_centerY; }
-    const Length& radiusX() const { return m_radiusX; }
-    const Length& radiusY() const { return m_radiusY; }
+    bool canBlend(const BasicShape&) const override;
+    Ref<BasicShape> blend(const BasicShape& from, double) const override;
 
-    void setCenterX(Length centerX) { m_centerX = std::move(centerX); }
-    void setCenterY(Length centerY) { m_centerY = std::move(centerY); }
-    void setRadiusX(Length radiusX) { m_radiusX = std::move(radiusX); }
-    void setRadiusY(Length radiusY) { m_radiusY = std::move(radiusY); }
+    bool operator==(const BasicShape&) const override;
 
-    virtual void path(Path&, const FloatRect&) override;
-    virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const override;
-
-    virtual Type type() const override { return DeprecatedBasicShapeEllipseType; }
-private:
-    DeprecatedBasicShapeEllipse() { }
-
-    Length m_centerX;
-    Length m_centerY;
-    Length m_radiusX;
-    Length m_radiusY;
+    BasicShapeCenterCoordinate m_centerX;
+    BasicShapeCenterCoordinate m_centerY;
+    BasicShapeRadius m_radiusX;
+    BasicShapeRadius m_radiusY;
 };
 
-class BasicShapePolygon : public BasicShape {
+class BasicShapePolygon final : public BasicShape {
 public:
-    static PassRefPtr<BasicShapePolygon> create() { return adoptRef(new BasicShapePolygon); }
+    static Ref<BasicShapePolygon> create() { return adoptRef(*new BasicShapePolygon); }
 
     const Vector<Length>& values() const { return m_values; }
     const Length& getXAt(unsigned i) const { return m_values[2 * i]; }
     const Length& getYAt(unsigned i) const { return m_values[2 * i + 1]; }
 
     void setWindRule(WindRule windRule) { m_windRule = windRule; }
-    void appendPoint(Length x, Length y) { m_values.append(std::move(x)); m_values.append(std::move(y)); }
-
-    virtual void path(Path&, const FloatRect&) override;
-    virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const override;
+    void appendPoint(Length x, Length y) { m_values.append(WTFMove(x)); m_values.append(WTFMove(y)); }
 
-    virtual WindRule windRule() const override { return m_windRule; }
+    WindRule windRule() const override { return m_windRule; }
 
-    virtual Type type() const override { return BasicShapePolygonType; }
 private:
-    BasicShapePolygon()
-        : m_windRule(RULE_NONZERO)
-    { }
+    BasicShapePolygon() = default;
+
+    Type type() const override { return BasicShapePolygonType; }
+
+    const Path& path(const FloatRect&) override;
 
-    WindRule m_windRule;
+    bool canBlend(const BasicShape&) const override;
+    Ref<BasicShape> blend(const BasicShape& from, double) const override;
+
+    bool operator==(const BasicShape&) const override;
+
+    WindRule m_windRule { RULE_NONZERO };
     Vector<Length> m_values;
 };
 
-class BasicShapeInsetRectangle : public BasicShape {
+class BasicShapePath final : public BasicShape {
 public:
-    static PassRefPtr<BasicShapeInsetRectangle> create() { return adoptRef(new BasicShapeInsetRectangle); }
-
-    const Length& top() const { return m_top; }
-    const Length& right() const { return m_right; }
-    const Length& bottom() const { return m_bottom; }
-    const Length& left() const { return m_left; }
-    const Length& cornerRadiusX() const { return m_cornerRadiusX; }
-    const Length& cornerRadiusY() const { return m_cornerRadiusY; }
-
-    void setTop(Length top) { m_top = std::move(top); }
-    void setRight(Length right) { m_right = std::move(right); }
-    void setBottom(Length bottom) { m_bottom = std::move(bottom); }
-    void setLeft(Length left) { m_left = std::move(left); }
-    void setCornerRadiusX(Length radiusX)
-    {
-        ASSERT(!radiusX.isUndefined());
-        m_cornerRadiusX = std::move(radiusX);
-    }
-    void setCornerRadiusY(Length radiusY)
+    static Ref<BasicShapePath> create(std::unique_ptr<SVGPathByteStream>&& byteStream)
     {
-        ASSERT(!radiusY.isUndefined());
-        m_cornerRadiusY = std::move(radiusY);
+        return adoptRef(*new BasicShapePath(WTFMove(byteStream)));
     }
 
-    virtual void path(Path&, const FloatRect&) override;
-    virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const override;
+    void setWindRule(WindRule windRule) { m_windRule = windRule; }
+    WindRule windRule() const override { return m_windRule; }
+
+    const SVGPathByteStream* pathData() const { return m_byteStream.get(); }
 
-    virtual Type type() const override { return BasicShapeInsetRectangleType; }
 private:
-    BasicShapeInsetRectangle() { }
+    BasicShapePath(std::unique_ptr<SVGPathByteStream>&&);
 
-    Length m_right;
-    Length m_top;
-    Length m_bottom;
-    Length m_left;
-    Length m_cornerRadiusX;
-    Length m_cornerRadiusY;
+    Type type() const override { return BasicShapePathType; }
+
+    const Path& path(const FloatRect&) override;
+
+    bool canBlend(const BasicShape&) const override;
+    Ref<BasicShape> blend(const BasicShape& from, double) const override;
+
+    bool operator==(const BasicShape&) const override;
+
+    std::unique_ptr<SVGPathByteStream> m_byteStream;
+    WindRule m_windRule { RULE_NONZERO };
 };
 
-class BasicShapeInset : public BasicShape {
+class BasicShapeInset final : public BasicShape {
 public:
-    static PassRefPtr<BasicShapeInset> create() { return adoptRef(new BasicShapeInset); }
+    static Ref<BasicShapeInset> create() { return adoptRef(*new BasicShapeInset); }
 
     const Length& top() const { return m_top; }
     const Length& right() const { return m_right; }
@@ -386,22 +307,27 @@ public:
     const LengthSize& bottomRightRadius() const { return m_bottomRightRadius; }
     const LengthSize& bottomLeftRadius() const { return m_bottomLeftRadius; }
 
-    void setTop(Length top) { m_top = std::move(top); }
-    void setRight(Length right) { m_right = std::move(right); }
-    void setBottom(Length bottom) { m_bottom = std::move(bottom); }
-    void setLeft(Length left) { m_left = std::move(left); }
+    void setTop(Length top) { m_top = WTFMove(top); }
+    void setRight(Length right) { m_right = WTFMove(right); }
+    void setBottom(Length bottom) { m_bottom = WTFMove(bottom); }
+    void setLeft(Length left) { m_left = WTFMove(left); }
 
-    void setTopLeftRadius(LengthSize radius) { m_topLeftRadius = std::move(radius); }
-    void setTopRightRadius(LengthSize radius) { m_topRightRadius = std::move(radius); }
-    void setBottomRightRadius(LengthSize radius) { m_bottomRightRadius = std::move(radius); }
-    void setBottomLeftRadius(LengthSize radius) { m_bottomLeftRadius = std::move(radius); }
+    void setTopLeftRadius(LengthSize radius) { m_topLeftRadius = WTFMove(radius); }
+    void setTopRightRadius(LengthSize radius) { m_topRightRadius = WTFMove(radius); }
+    void setBottomRightRadius(LengthSize radius) { m_bottomRightRadius = WTFMove(radius); }
+    void setBottomLeftRadius(LengthSize radius) { m_bottomLeftRadius = WTFMove(radius); }
 
-    virtual void path(Path&, const FloatRect&) override;
-    virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const override;
-
-    virtual Type type() const override { return BasicShapeInsetType; }
 private:
-    BasicShapeInset() { }
+    BasicShapeInset() = default;
+
+    Type type() const override { return BasicShapeInsetType; }
+
+    const Path& path(const FloatRect&) override;
+
+    bool canBlend(const BasicShape&) const override;
+    Ref<BasicShape> blend(const BasicShape& from, double) const override;
+
+    bool operator==(const BasicShape&) const override;
 
     Length m_right;
     Length m_top;
@@ -414,5 +340,15 @@ private:
     LengthSize m_bottomLeftRadius;
 };
 
-}
-#endif
+} // namespace WebCore
+
+#define SPECIALIZE_TYPE_TRAITS_BASIC_SHAPE(ToValueTypeName, predicate) \
+SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::ToValueTypeName) \
+    static bool isType(const WebCore::BasicShape& basicShape) { return basicShape.type() == WebCore::predicate; } \
+SPECIALIZE_TYPE_TRAITS_END()
+
+SPECIALIZE_TYPE_TRAITS_BASIC_SHAPE(BasicShapeCircle, BasicShape::BasicShapeCircleType)
+SPECIALIZE_TYPE_TRAITS_BASIC_SHAPE(BasicShapeEllipse, BasicShape::BasicShapeEllipseType)
+SPECIALIZE_TYPE_TRAITS_BASIC_SHAPE(BasicShapePolygon, BasicShape::BasicShapePolygonType)
+SPECIALIZE_TYPE_TRAITS_BASIC_SHAPE(BasicShapePath, BasicShape::BasicShapePathType)
+SPECIALIZE_TYPE_TRAITS_BASIC_SHAPE(BasicShapeInset, BasicShape::BasicShapeInsetType)