Rename LayoutBox to CSSBoxType

Source/core/css/CSSBasicShapes.cpp

 /*
  * 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 23 matching lines @@
 #include "core/css/Pair.h"
 #include "platform/Length.h"
 #include "wtf/text/StringBuilder.h"
 
 using namespace WTF;
 
 namespace WebCore {
 
 DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(CSSBasicShape)
 
-static String buildCircleString(const String& radius, const String& centerX, const String& centerY, const String& layoutBox)
+static String buildCircleString(const String& radius, const String& centerX, const String& centerY, const String& box)
 {
     char at[] = "at";
     char separator[] = " ";
     StringBuilder result;
     result.appendLiteral("circle(");
     if (!radius.isNull())
         result.append(radius);
 
     if (!centerX.isNull() || !centerY.isNull()) {
         if (!radius.isNull())
             result.appendLiteral(separator);
         result.append(at);
         result.appendLiteral(separator);
         result.append(centerX);
         result.appendLiteral(separator);
         result.append(centerY);
     }
     result.append(")");
-    if (layoutBox.length()) {
+    if (box.length()) {
         result.appendLiteral(separator);
-        result.append(layoutBox);
+        result.append(box);
     }
     return result.toString();
 }
 
 static String serializePositionOffset(const Pair& offset, const Pair& other)
 {
     if ((offset.first()->getValueID() == CSSValueLeft && other.first()->getValueID() == CSSValueTop)
         || (offset.first()->getValueID() == CSSValueTop && other.first()->getValueID() == CSSValueLeft))
         return offset.second()->cssText();
     return offset.cssText();
@@ skipping 34 matching lines @@
 }
 
 String CSSBasicShapeCircle::cssText() const
 {
     RefPtrWillBeRawPtr<CSSPrimitiveValue> normalizedCX = buildSerializablePositionOffset(m_centerX, CSSValueLeft);
     RefPtrWillBeRawPtr<CSSPrimitiveValue> normalizedCY = buildSerializablePositionOffset(m_centerY, CSSValueTop);
 
     return buildCircleString(m_radius ? m_radius->cssText() : String(),
         serializePositionOffset(*normalizedCX->getPairValue(), *normalizedCY->getPairValue()),
         serializePositionOffset(*normalizedCY->getPairValue(), *normalizedCX->getPairValue()),
-        m_layoutBox ? m_layoutBox->cssText() : String());
+        m_referenceBox ? m_referenceBox->cssText() : String());
 }
 
 bool CSSBasicShapeCircle::equals(const CSSBasicShape& shape) const
 {
     if (shape.type() != CSSBasicShapeCircleType)
         return false;
 
     const CSSBasicShapeCircle& other = static_cast<const CSSBasicShapeCircle&>(shape);
     return compareCSSValuePtr(m_centerX, other.m_centerX)
         && compareCSSValuePtr(m_centerY, other.m_centerY)
         && compareCSSValuePtr(m_radius, other.m_radius)
-        && compareCSSValuePtr(m_layoutBox, other.m_layoutBox);
+        && compareCSSValuePtr(m_referenceBox, other.m_referenceBox);
 }
 
 void CSSBasicShapeCircle::trace(Visitor* visitor)
 {
     visitor->trace(m_centerX);
     visitor->trace(m_centerY);
     visitor->trace(m_radius);
     CSSBasicShape::trace(visitor);
 }
 
@@ skipping 34 matching lines @@
 
 String CSSBasicShapeEllipse::cssText() const
 {
     RefPtrWillBeRawPtr<CSSPrimitiveValue> normalizedCX = buildSerializablePositionOffset(m_centerX, CSSValueLeft);
     RefPtrWillBeRawPtr<CSSPrimitiveValue> normalizedCY = buildSerializablePositionOffset(m_centerY, CSSValueTop);
 
     return buildEllipseString(m_radiusX ? m_radiusX->cssText() : String(),
         m_radiusY ? m_radiusY->cssText() : String(),
         serializePositionOffset(*normalizedCX->getPairValue(), *normalizedCY->getPairValue()),
         serializePositionOffset(*normalizedCY->getPairValue(), *normalizedCX->getPairValue()),
-        m_layoutBox ? m_layoutBox->cssText() : String());
+        m_referenceBox ? m_referenceBox->cssText() : String());
 }
 
 bool CSSBasicShapeEllipse::equals(const CSSBasicShape& shape) const
 {
     if (shape.type() != CSSBasicShapeEllipseType)
         return false;
 
     const CSSBasicShapeEllipse& other = static_cast<const CSSBasicShapeEllipse&>(shape);
     return compareCSSValuePtr(m_centerX, other.m_centerX)
         && compareCSSValuePtr(m_centerY, other.m_centerY)
         && compareCSSValuePtr(m_radiusX, other.m_radiusX)
         && compareCSSValuePtr(m_radiusY, other.m_radiusY)
-        && compareCSSValuePtr(m_layoutBox, other.m_layoutBox);
+        && compareCSSValuePtr(m_referenceBox, other.m_referenceBox);
 }
 
 void CSSBasicShapeEllipse::trace(Visitor* visitor)
 {
     visitor->trace(m_centerX);
     visitor->trace(m_centerY);
     visitor->trace(m_radiusX);
     visitor->trace(m_radiusY);
     CSSBasicShape::trace(visitor);
 }
 
-static String buildPolygonString(const WindRule& windRule, const Vector<String>& points, const String& layoutBox)
+static String buildPolygonString(const WindRule& windRule, const Vector<String>& points, const String& box)
 {
     ASSERT(!(points.size() % 2));
 
     StringBuilder result;
     const char evenOddOpening[] = "polygon(evenodd, ";
     const char nonZeroOpening[] = "polygon(";
     const char commaSeparator[] = ", ";
     COMPILE_ASSERT(sizeof(evenOddOpening) > sizeof(nonZeroOpening), polygon_string_openings_have_same_length);
 
     // Compute the required capacity in advance to reduce allocations.
     size_t length = sizeof(evenOddOpening) - 1;
     for (size_t i = 0; i < points.size(); i += 2) {
         if (i)
             length += (sizeof(commaSeparator) - 1);
         // add length of two strings, plus one for the space separator.
         length += points[i].length() + 1 + points[i + 1].length();
     }
-    if (!layoutBox.isEmpty())
-        length += layoutBox.length() + 1;
+    if (!box.isEmpty())
+        length += box.length() + 1;
     result.reserveCapacity(length);
 
     if (windRule == RULE_EVENODD)
         result.appendLiteral(evenOddOpening);
     else
         result.appendLiteral(nonZeroOpening);
 
     for (size_t i = 0; i < points.size(); i += 2) {
         if (i)
             result.appendLiteral(commaSeparator);
         result.append(points[i]);
         result.append(' ');
         result.append(points[i + 1]);
     }
 
     result.append(')');
 
-    if (!layoutBox.isEmpty()) {
+    if (!box.isEmpty()) {
         result.append(' ');
-        result.append(layoutBox);
+        result.append(box);
     }
 
     return result.toString();
 }
 
 String CSSBasicShapePolygon::cssText() const
 {
     Vector<String> points;
     points.reserveInitialCapacity(m_values.size());
 
     for (size_t i = 0; i < m_values.size(); ++i)
         points.append(m_values.at(i)->cssText());
 
-    return buildPolygonString(m_windRule, points, m_layoutBox ? m_layoutBox->cssText() : String());
+    return buildPolygonString(m_windRule, points, m_referenceBox ? m_referenceBox->cssText() : String());
 }
 
 bool CSSBasicShapePolygon::equals(const CSSBasicShape& shape) const
 {
     if (shape.type() != CSSBasicShapePolygonType)
         return false;
 
     const CSSBasicShapePolygon& rhs = static_cast<const CSSBasicShapePolygon&>(shape);
 
-    if (!compareCSSValuePtr(m_layoutBox, rhs.m_layoutBox))
+    if (!compareCSSValuePtr(m_referenceBox, rhs.m_referenceBox))
         return false;
 
     return compareCSSValueVector(m_values, rhs.m_values);
 }
 
 void CSSBasicShapePolygon::trace(Visitor* visitor)
 {
     visitor->trace(m_values);
     CSSBasicShape::trace(visitor);
 }
@@ skipping 118 matching lines @@
     visitor->trace(m_left);
     visitor->trace(m_topLeftRadius);
     visitor->trace(m_topRightRadius);
     visitor->trace(m_bottomRightRadius);
     visitor->trace(m_bottomLeftRadius);
     CSSBasicShape::trace(visitor);
 }
 
 } // namespace WebCore