Changed Pair to be a CSSValue

Source/core/css/CSSBasicShapes.h

 /*
  * Copyright (C) 2011 Adobe Systems Incorporated. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above
  *    copyright notice, this list of conditions and the following
  *    disclaimer.
@@ skipping 13 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 
 #ifndef CSSBasicShapes_h
 #define CSSBasicShapes_h
 
 #include "core/css/CSSPrimitiveValue.h"
+#include "core/css/CSSValuePair.h"
 #include "platform/graphics/GraphicsTypes.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 class CSSBasicShape : public RefCountedWillBeGarbageCollected<CSSBasicShape> {
     DECLARE_EMPTY_VIRTUAL_DESTRUCTOR_WILL_BE_REMOVED(CSSBasicShape);
 public:
@@ skipping 23 matching lines @@
     RefPtrWillBeMember<CSSPrimitiveValue> m_referenceBox;
 };
 
 class CSSBasicShapeCircle final : public CSSBasicShape {
 public:
     static PassRefPtrWillBeRawPtr<CSSBasicShapeCircle> create() { return adoptRefWillBeNoop(new CSSBasicShapeCircle); }
 
     String cssText() const override;
     bool equals(const CSSBasicShape&) const override;
 
-    CSSPrimitiveValue* centerX() const { return m_centerX.get(); }
-    CSSPrimitiveValue* centerY() const { return m_centerY.get(); }
+    CSSValue* centerX() const { return m_centerX.get(); }
+    CSSValue* centerY() const { return m_centerY.get(); }
     CSSPrimitiveValue* radius() const { return m_radius.get(); }
 
-    void setCenterX(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> centerX) { m_centerX = centerX; }
-    void setCenterY(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> centerY) { m_centerY = centerY; }
+    void setCenterX(PassRefPtrWillBeRawPtr<CSSValue> centerX) { m_centerX = centerX; }
+    void setCenterY(PassRefPtrWillBeRawPtr<CSSValue> centerY) { m_centerY = centerY; }
     void setRadius(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> radius) { m_radius = radius; }
 
     DECLARE_VIRTUAL_TRACE();
 
 private:
     CSSBasicShapeCircle() { }
 
     Type type() const override { return CSSBasicShapeCircleType; }
 
-    RefPtrWillBeMember<CSSPrimitiveValue> m_centerX;
-    RefPtrWillBeMember<CSSPrimitiveValue> m_centerY;
+    RefPtrWillBeMember<CSSValue> m_centerX;
+    RefPtrWillBeMember<CSSValue> m_centerY;
     RefPtrWillBeMember<CSSPrimitiveValue> m_radius;
 };
 
 class CSSBasicShapeEllipse final : public CSSBasicShape {
 public:
     static PassRefPtrWillBeRawPtr<CSSBasicShapeEllipse> create() { return adoptRefWillBeNoop(new CSSBasicShapeEllipse); }
 
     String cssText() const override;
     bool equals(const CSSBasicShape&) const override;
 
-    CSSPrimitiveValue* centerX() const { return m_centerX.get(); }
-    CSSPrimitiveValue* centerY() const { return m_centerY.get(); }
+    CSSValue* centerX() const { return m_centerX.get(); }
+    CSSValue* centerY() const { return m_centerY.get(); }
     CSSPrimitiveValue* radiusX() const { return m_radiusX.get(); }
     CSSPrimitiveValue* radiusY() const { return m_radiusY.get(); }
 
-    void setCenterX(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> centerX) { m_centerX = centerX; }
-    void setCenterY(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> centerY) { m_centerY = centerY; }
+    void setCenterX(PassRefPtrWillBeRawPtr<CSSValue> centerX) { m_centerX = centerX; }
+    void setCenterY(PassRefPtrWillBeRawPtr<CSSValue> centerY) { m_centerY = centerY; }
     void setRadiusX(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> radiusX) { m_radiusX = radiusX; }
     void setRadiusY(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> radiusY) { m_radiusY = radiusY; }
 
     DECLARE_VIRTUAL_TRACE();
 
 private:
     CSSBasicShapeEllipse() { }
 
     Type type() const override { return CSSBasicShapeEllipseType; }
 
-    RefPtrWillBeMember<CSSPrimitiveValue> m_centerX;
-    RefPtrWillBeMember<CSSPrimitiveValue> m_centerY;
+    RefPtrWillBeMember<CSSValue> m_centerX;
+    RefPtrWillBeMember<CSSValue> m_centerY;
     RefPtrWillBeMember<CSSPrimitiveValue> m_radiusX;
     RefPtrWillBeMember<CSSPrimitiveValue> m_radiusY;
 };
 
 class CSSBasicShapePolygon final : public CSSBasicShape {
 public:
     static PassRefPtrWillBeRawPtr<CSSBasicShapePolygon> create() { return adoptRefWillBeNoop(new CSSBasicShapePolygon); }
 
     void appendPoint(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> x, PassRefPtrWillBeRawPtr<CSSPrimitiveValue> y)
     {
@@ skipping 27 matching lines @@
 
 class CSSBasicShapeInset final : public CSSBasicShape {
 public:
     static PassRefPtrWillBeRawPtr<CSSBasicShapeInset> create() { return adoptRefWillBeNoop(new CSSBasicShapeInset); }
 
     CSSPrimitiveValue* top() const { return m_top.get(); }
     CSSPrimitiveValue* right() const { return m_right.get(); }
     CSSPrimitiveValue* bottom() const { return m_bottom.get(); }
     CSSPrimitiveValue* left() const { return m_left.get(); }
 
-    CSSPrimitiveValue* topLeftRadius() const { return m_topLeftRadius.get(); }
-    CSSPrimitiveValue* topRightRadius() const { return m_topRightRadius.get(); }
-    CSSPrimitiveValue* bottomRightRadius() const { return m_bottomRightRadius.get(); }
-    CSSPrimitiveValue* bottomLeftRadius() const { return m_bottomLeftRadius.get(); }
+    CSSValuePair* topLeftRadius() const { return m_topLeftRadius.get(); }
+    CSSValuePair* topRightRadius() const { return m_topRightRadius.get(); }
+    CSSValuePair* bottomRightRadius() const { return m_bottomRightRadius.get(); }
+    CSSValuePair* bottomLeftRadius() const { return m_bottomLeftRadius.get(); }
 
     void setTop(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> top) { m_top = top; }
     void setRight(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> right) { m_right = right; }
     void setBottom(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> bottom) { m_bottom = bottom; }
     void setLeft(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> left) { m_left = left; }
 
     void updateShapeSize4Values(CSSPrimitiveValue* top, CSSPrimitiveValue* right, CSSPrimitiveValue* bottom, CSSPrimitiveValue* left)
     {
         setTop(top);
         setRight(right);
@@ skipping 10 matching lines @@
     {
         updateShapeSize4Values(value1, value2, value1, value2);
     }
 
     void updateShapeSize3Values(CSSPrimitiveValue* value1, CSSPrimitiveValue* value2,  CSSPrimitiveValue* value3)
     {
         updateShapeSize4Values(value1, value2, value3, value2);
     }
 
 
-    void setTopLeftRadius(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> radius) { m_topLeftRadius = radius; }
-    void setTopRightRadius(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> radius) { m_topRightRadius = radius; }
-    void setBottomRightRadius(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> radius) { m_bottomRightRadius = radius; }
-    void setBottomLeftRadius(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> radius) { m_bottomLeftRadius = radius; }
+    void setTopLeftRadius(PassRefPtrWillBeRawPtr<CSSValuePair> radius) { m_topLeftRadius = radius; }
+    void setTopRightRadius(PassRefPtrWillBeRawPtr<CSSValuePair> radius) { m_topRightRadius = radius; }
+    void setBottomRightRadius(PassRefPtrWillBeRawPtr<CSSValuePair> radius) { m_bottomRightRadius = radius; }
+    void setBottomLeftRadius(PassRefPtrWillBeRawPtr<CSSValuePair> radius) { m_bottomLeftRadius = radius; }
 
     String cssText() const override;
     bool equals(const CSSBasicShape&) const override;
 
     DECLARE_VIRTUAL_TRACE();
 
 private:
     CSSBasicShapeInset() { }
 
     Type type() const override { return CSSBasicShapeInsetType; }
 
     RefPtrWillBeMember<CSSPrimitiveValue> m_top;
     RefPtrWillBeMember<CSSPrimitiveValue> m_right;
     RefPtrWillBeMember<CSSPrimitiveValue> m_bottom;
     RefPtrWillBeMember<CSSPrimitiveValue> m_left;
 
-    RefPtrWillBeMember<CSSPrimitiveValue> m_topLeftRadius;
-    RefPtrWillBeMember<CSSPrimitiveValue> m_topRightRadius;
-    RefPtrWillBeMember<CSSPrimitiveValue> m_bottomRightRadius;
-    RefPtrWillBeMember<CSSPrimitiveValue> m_bottomLeftRadius;
+    RefPtrWillBeMember<CSSValuePair> m_topLeftRadius;
+    RefPtrWillBeMember<CSSValuePair> m_topRightRadius;
+    RefPtrWillBeMember<CSSValuePair> m_bottomRightRadius;
+    RefPtrWillBeMember<CSSValuePair> m_bottomLeftRadius;
 };
 
 DEFINE_TYPE_CASTS(CSSBasicShapeCircle, CSSBasicShape, shape, shape->isCircle(), shape.isCircle());
 DEFINE_TYPE_CASTS(CSSBasicShapeEllipse, CSSBasicShape, shape, shape->isEllipse(), shape.isEllipse());
 DEFINE_TYPE_CASTS(CSSBasicShapePolygon, CSSBasicShape, shape, shape->isPolygon(), shape.isPolygon());
 DEFINE_TYPE_CASTS(CSSBasicShapeInset, CSSBasicShape, shape, shape->isInset(), shape.isInset());
 
 } // namespace blink
 
 #endif // CSSBasicShapes_h