Switch arguments to const Length references for performance

Source/core/rendering/style/BasicShapes.h

 /*
  * Copyright (C) 2012 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 70 matching lines @@
         TopLeft,
         BottomRight
     };
     BasicShapeCenterCoordinate()
         : m_direction(TopLeft)
         , m_length(Undefined)
     {
         updateComputedLength();
     }
 
-    BasicShapeCenterCoordinate(Direction direction, Length length)
+    BasicShapeCenterCoordinate(Direction direction, const Length& length)
         : m_direction(direction)
         , m_length(length)
     {
         updateComputedLength();
     }
 
     BasicShapeCenterCoordinate(const BasicShapeCenterCoordinate& other)
         : m_direction(other.direction())
         , m_length(other.length())
         , m_computedLength(other.m_computedLength)
@@ skipping 20 matching lines @@
 };
 
 class BasicShapeRadius {
 public:
     enum Type {
         Value,
         ClosestSide,
         FarthestSide
     };
     BasicShapeRadius() : m_value(Undefined), m_type(ClosestSide) { }
-    explicit BasicShapeRadius(Length v) : m_value(v), m_type(Value) { }
+    explicit BasicShapeRadius(const 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()) { }
     bool operator==(const BasicShapeRadius& other) const { return m_type == other.m_type && m_value == other.m_value; }
 
     const Length& value() const { return m_value; }
     Type type() const { return m_type; }
 
     bool canBlend(const BasicShapeRadius& other) const
     {
         // FIXME determine how to interpolate between keywords. See issue 330248.
@@ skipping 75 matching lines @@
 
 class BasicShapePolygon FINAL : public BasicShape {
 public:
     static PassRefPtr<BasicShapePolygon> create() { return adoptRef(new BasicShapePolygon); }
 
     const Vector<Length>& values() const { return m_values; }
     Length getXAt(unsigned i) const { return m_values.at(2 * i); }
     Length getYAt(unsigned i) const { return m_values.at(2 * i + 1); }
 
     void setWindRule(WindRule windRule) { m_windRule = windRule; }
-    void appendPoint(Length x, Length y) { m_values.append(x); m_values.append(y); }
+    void appendPoint(const Length& x, const Length& y) { m_values.append(x); m_values.append(y); }
 
     virtual void path(Path&, const FloatRect&) OVERRIDE;
     virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const OVERRIDE;
     virtual bool operator==(const BasicShape&) const OVERRIDE;
 
     virtual WindRule windRule() const OVERRIDE { return m_windRule; }
 
     virtual Type type() const OVERRIDE { return BasicShapePolygonType; }
 private:
     BasicShapePolygon()
@@ skipping 13 matching lines @@
     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 LengthSize& topLeftRadius() const { return m_topLeftRadius; }
     const LengthSize& topRightRadius() const { return m_topRightRadius; }
     const LengthSize& bottomRightRadius() const { return m_bottomRightRadius; }
     const LengthSize& bottomLeftRadius() const { return m_bottomLeftRadius; }
 
-    void setTop(Length top) { m_top = top; }
-    void setRight(Length right) { m_right = right; }
-    void setBottom(Length bottom) { m_bottom = bottom; }
-    void setLeft(Length left) { m_left = left; }
+    void setTop(const Length& top) { m_top = top; }
+    void setRight(const Length& right) { m_right = right; }
+    void setBottom(const Length& bottom) { m_bottom = bottom; }
+    void setLeft(const Length& left) { m_left = left; }
 
-    void setTopLeftRadius(LengthSize radius) { m_topLeftRadius = radius; }
-    void setTopRightRadius(LengthSize radius) { m_topRightRadius = radius; }
-    void setBottomRightRadius(LengthSize radius) { m_bottomRightRadius = radius; }
-    void setBottomLeftRadius(LengthSize radius) { m_bottomLeftRadius = radius; }
+    void setTopLeftRadius(const LengthSize& radius) { m_topLeftRadius = radius; }
+    void setTopRightRadius(const LengthSize& radius) { m_topRightRadius = radius; }
+    void setBottomRightRadius(const LengthSize& radius) { m_bottomRightRadius = radius; }
+    void setBottomLeftRadius(const LengthSize& radius) { m_bottomLeftRadius = radius; }
 
     virtual void path(Path&, const FloatRect&) OVERRIDE;
     virtual PassRefPtr<BasicShape> blend(const BasicShape*, double) const OVERRIDE;
     virtual bool operator==(const BasicShape&) const OVERRIDE;
 
     virtual Type type() const OVERRIDE { return BasicShapeInsetType; }
 private:
     BasicShapeInset() { }
 
     Length m_right;
     Length m_top;
     Length m_bottom;
     Length m_left;
 
     LengthSize m_topLeftRadius;
     LengthSize m_topRightRadius;
     LengthSize m_bottomRightRadius;
     LengthSize m_bottomLeftRadius;
 };
 
 DEFINE_BASICSHAPE_TYPE_CASTS(BasicShapeInset);
 
 }
 #endif