CSSValue Immediates: Replace CSSPrimitiveValue usage with const references

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 34 matching lines @@
         CSSBasicShapeEllipseType,
         CSSBasicShapePolygonType,
         CSSBasicShapeCircleType,
         CSSBasicShapeInsetType
     };
 
     virtual Type type() const = 0;
     virtual String cssText() const = 0;
     virtual bool equals(const CSSBasicShape&) const = 0;
 
-    NullableCSSValue referenceBox() const { return m_referenceBox; }
-    void setReferenceBox(CSSPrimitiveValue referenceBox) { m_referenceBox = referenceBox; }
+    const NullableCSSValue& referenceBox() const { return m_referenceBox; }
+    void setReferenceBox(const CSSPrimitiveValue& referenceBox) { m_referenceBox = referenceBox; }
 
     bool isEllipse() const { return type() == CSSBasicShapeEllipseType; }
     bool isPolygon() const { return type() == CSSBasicShapePolygonType; }
     bool isCircle() const { return type() == CSSBasicShapeCircleType; }
     bool isInset() const { return type() == CSSBasicShapeInsetType; }
 
     DEFINE_INLINE_VIRTUAL_TRACE() { visitor->trace(m_referenceBox); }
 
 protected:
     CSSBasicShape() { }
     NullableCSSValue m_referenceBox;
 };
 
 class CSSBasicShapeCircle final : public CSSBasicShape {
 public:
     static PassRefPtrWillBeRawPtr<CSSBasicShapeCircle> create() { return adoptRefWillBeNoop(new CSSBasicShapeCircle); }
 
     virtual String cssText() const override;
     virtual bool equals(const CSSBasicShape&) const override;
 
-    NullableCSSValue centerX() const { return m_centerX; }
-    NullableCSSValue centerY() const { return m_centerY; }
-    NullableCSSValue radius() const { return m_radius; }
+    const NullableCSSValue& centerX() const { return m_centerX; }
+    const NullableCSSValue& centerY() const { return m_centerY; }
+    const NullableCSSValue& radius() const { return m_radius; }
 
-    void setCenterX(CSSPrimitiveValue centerX) { m_centerX = centerX; }
-    void setCenterY(CSSPrimitiveValue centerY) { m_centerY = centerY; }
-    void setRadius(CSSPrimitiveValue radius) { m_radius = radius; }
+    void setCenterX(const CSSPrimitiveValue& centerX) { m_centerX = centerX; }
+    void setCenterY(const CSSPrimitiveValue& centerY) { m_centerY = centerY; }
+    void setRadius(const CSSPrimitiveValue& radius) { m_radius = radius; }
 
     DECLARE_VIRTUAL_TRACE();
 
 private:
     CSSBasicShapeCircle() { }
 
     virtual Type type() const override { return CSSBasicShapeCircleType; }
 
     NullableCSSValue m_centerX;
     NullableCSSValue m_centerY;
     NullableCSSValue m_radius;
 };
 
 class CSSBasicShapeEllipse final : public CSSBasicShape {
 public:
     static PassRefPtrWillBeRawPtr<CSSBasicShapeEllipse> create() { return adoptRefWillBeNoop(new CSSBasicShapeEllipse); }
 
     virtual String cssText() const override;
     virtual bool equals(const CSSBasicShape&) const override;
 
-    NullableCSSValue centerX() const { return m_centerX; }
-    NullableCSSValue centerY() const { return m_centerY; }
-    NullableCSSValue radiusX() const { return m_radiusX; }
-    NullableCSSValue radiusY() const { return m_radiusY; }
+    const NullableCSSValue& centerX() const { return m_centerX; }
+    const NullableCSSValue& centerY() const { return m_centerY; }
+    const NullableCSSValue& radiusX() const { return m_radiusX; }
+    const NullableCSSValue& radiusY() const { return m_radiusY; }
 
     void setCenterX(CSSPrimitiveValue centerX) { m_centerX = centerX; }
     void setCenterY(CSSPrimitiveValue centerY) { m_centerY = centerY; }
     void setRadiusX(CSSPrimitiveValue radiusX) { m_radiusX = radiusX; }
     void setRadiusY(CSSPrimitiveValue radiusY) { m_radiusY = radiusY; }
 
     DECLARE_VIRTUAL_TRACE();
 
 private:
     CSSBasicShapeEllipse() { }
 
     virtual Type type() const override { return CSSBasicShapeEllipseType; }
 
     NullableCSSValue m_centerX;
     NullableCSSValue m_centerY;
     NullableCSSValue m_radiusX;
     NullableCSSValue m_radiusY;
 };
 
 class CSSBasicShapePolygon final : public CSSBasicShape {
 public:
     static PassRefPtrWillBeRawPtr<CSSBasicShapePolygon> create() { return adoptRefWillBeNoop(new CSSBasicShapePolygon); }
 
-    void appendPoint(CSSPrimitiveValue x, CSSPrimitiveValue y)
+    void appendPoint(const CSSPrimitiveValue& x, const CSSPrimitiveValue& y)
     {
         m_values.append(x);
         m_values.append(y);
     }
 
-    CSSPrimitiveValue getXAt(unsigned i) const { return toCSSPrimitiveValue(m_values.at(i * 2)); }
-    CSSPrimitiveValue getYAt(unsigned i) const { return toCSSPrimitiveValue(m_values.at(i * 2 + 1)); }
+    const CSSPrimitiveValue& getXAt(unsigned i) const { return toCSSPrimitiveValue(m_values.at(i * 2)); }
+    const CSSPrimitiveValue& getYAt(unsigned i) const { return toCSSPrimitiveValue(m_values.at(i * 2 + 1)); }
     const WillBeHeapVector<CSSValue>& values() const { return m_values; }
 
     void setWindRule(WindRule w) { m_windRule = w; }
     WindRule windRule() const { return m_windRule; }
 
     virtual String cssText() const override;
     virtual bool equals(const CSSBasicShape&) const override;
 
     DECLARE_VIRTUAL_TRACE();
 
 private:
     CSSBasicShapePolygon()
         : m_windRule(RULE_NONZERO)
     {
     }
 
     virtual Type type() const override { return CSSBasicShapePolygonType; }
 
     WillBeHeapVector<CSSValue> m_values;
     WindRule m_windRule;
 };
 
 class CSSBasicShapeInset final : public CSSBasicShape {
 public:
     static PassRefPtrWillBeRawPtr<CSSBasicShapeInset> create() { return adoptRefWillBeNoop(new CSSBasicShapeInset); }
 
-    CSSPrimitiveValue top() const { return toCSSPrimitiveValue(*m_top); }
-    CSSPrimitiveValue right() const { return toCSSPrimitiveValue(*m_right); }
-    CSSPrimitiveValue bottom() const { return toCSSPrimitiveValue(*m_bottom); }
-    CSSPrimitiveValue left() const { return toCSSPrimitiveValue(*m_left); }
+    const CSSPrimitiveValue& top() const { return toCSSPrimitiveValue(m_top); }
+    const CSSPrimitiveValue& right() const { return toCSSPrimitiveValue(m_right); }
+    const CSSPrimitiveValue& bottom() const { return toCSSPrimitiveValue(m_bottom); }
+    const CSSPrimitiveValue& left() const { return toCSSPrimitiveValue(m_left); }
 
-    NullableCSSValue topLeftRadius() const { return m_topLeftRadius; }
-    NullableCSSValue topRightRadius() const { return m_topRightRadius; }
-    NullableCSSValue bottomRightRadius() const { return m_bottomRightRadius; }
-    NullableCSSValue bottomLeftRadius() const { return m_bottomLeftRadius; }
+    const NullableCSSValue& topLeftRadius() const { return m_topLeftRadius; }
+    const NullableCSSValue& topRightRadius() const { return m_topRightRadius; }
+    const NullableCSSValue& bottomRightRadius() const { return m_bottomRightRadius; }
+    const NullableCSSValue& bottomLeftRadius() const { return m_bottomLeftRadius; }
 
-    void setTop(CSSPrimitiveValue top) { m_top = top; }
-    void setRight(CSSPrimitiveValue right) { m_right = right; }
-    void setBottom(CSSPrimitiveValue bottom) { m_bottom = bottom; }
-    void setLeft(CSSPrimitiveValue left) { m_left = left; }
+    void setTop(const CSSPrimitiveValue& top) { m_top = top; }
+    void setRight(const CSSPrimitiveValue& right) { m_right = right; }
+    void setBottom(const CSSPrimitiveValue& bottom) { m_bottom = bottom; }
+    void setLeft(const CSSPrimitiveValue& left) { m_left = left; }
 
-    void updateShapeSize4Values(CSSPrimitiveValue top, CSSPrimitiveValue right, CSSPrimitiveValue bottom, CSSPrimitiveValue left)
+    void updateShapeSize4Values(const CSSPrimitiveValue& top, const CSSPrimitiveValue& right, const CSSPrimitiveValue& bottom, const CSSPrimitiveValue& left)
     {
         setTop(top);
         setRight(right);
         setBottom(bottom);
         setLeft(left);
     }
 
-    void updateShapeSize1Value(CSSPrimitiveValue value1)
+    void updateShapeSize1Value(const CSSPrimitiveValue& value1)
     {
         updateShapeSize4Values(value1, value1, value1, value1);
     }
 
-    void updateShapeSize2Values(CSSPrimitiveValue value1,  CSSPrimitiveValue value2)
+    void updateShapeSize2Values(const CSSPrimitiveValue& value1,  const CSSPrimitiveValue& value2)
     {
         updateShapeSize4Values(value1, value2, value1, value2);
     }
 
-    void updateShapeSize3Values(CSSPrimitiveValue value1, CSSPrimitiveValue value2,  CSSPrimitiveValue value3)
+    void updateShapeSize3Values(const CSSPrimitiveValue& value1, const CSSPrimitiveValue& value2,  const CSSPrimitiveValue& value3)
     {
         updateShapeSize4Values(value1, value2, value3, value2);
     }
 
 
-    void setTopLeftRadius(CSSPrimitiveValue radius) { m_topLeftRadius = radius; }
-    void setTopRightRadius(CSSPrimitiveValue radius) { m_topRightRadius = radius; }
-    void setBottomRightRadius(CSSPrimitiveValue radius) { m_bottomRightRadius = radius; }
-    void setBottomLeftRadius(CSSPrimitiveValue radius) { m_bottomLeftRadius = radius; }
+    void setTopLeftRadius(const CSSPrimitiveValue& radius) { m_topLeftRadius = radius; }
+    void setTopRightRadius(const CSSPrimitiveValue& radius) { m_topRightRadius = radius; }
+    void setBottomRightRadius(const CSSPrimitiveValue& radius) { m_bottomRightRadius = radius; }
+    void setBottomLeftRadius(const CSSPrimitiveValue& radius) { m_bottomLeftRadius = radius; }
 
     virtual String cssText() const override;
     virtual bool equals(const CSSBasicShape&) const override;
 
     DECLARE_VIRTUAL_TRACE();
 
 private:
     CSSBasicShapeInset() { }
 
     virtual Type type() const override { return CSSBasicShapeInsetType; }
@@ skipping 10 matching lines @@
 };
 
 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