Remove unused CSSBasicShape::m_referenceBox

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 blink {
 
 DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(CSSBasicShape)
 
-static String buildCircleString(const String& radius, const String& centerX, const String& centerY, const String& box)
+static String buildCircleString(const String& radius, const String& centerX, const String& centerY)
 {
     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 (box.length()) {
-        result.appendLiteral(separator);
-        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 36 matching lines @@
 {
     RefPtrWillBeRawPtr<CSSPrimitiveValue> normalizedCX = buildSerializablePositionOffset(m_centerX, CSSValueLeft);
     RefPtrWillBeRawPtr<CSSPrimitiveValue> normalizedCY = buildSerializablePositionOffset(m_centerY, CSSValueTop);
 
     String radius;
     if (m_radius && m_radius->getValueID() != CSSValueClosestSide)
         radius = m_radius->cssText();
 
     return buildCircleString(radius,
         serializePositionOffset(*normalizedCX->getPairValue(), *normalizedCY->getPairValue()),
-        serializePositionOffset(*normalizedCY->getPairValue(), *normalizedCX->getPairValue()),
-        m_referenceBox ? m_referenceBox->cssText() : String());
+        serializePositionOffset(*normalizedCY->getPairValue(), *normalizedCX->getPairValue()));
 }
 
 bool CSSBasicShapeCircle::equals(const CSSBasicShape& shape) const
 {
     if (shape.type() != CSSBasicShapeCircleType)
         return false;
 
     const CSSBasicShapeCircle& other = toCSSBasicShapeCircle(shape);
     return compareCSSValuePtr(m_centerX, other.m_centerX)
         && compareCSSValuePtr(m_centerY, other.m_centerY)
-        && compareCSSValuePtr(m_radius, other.m_radius)
-        && compareCSSValuePtr(m_referenceBox, other.m_referenceBox);
+        && compareCSSValuePtr(m_radius, other.m_radius);
 }
 
 DEFINE_TRACE(CSSBasicShapeCircle)
 {
     visitor->trace(m_centerX);
     visitor->trace(m_centerY);
     visitor->trace(m_radius);
     CSSBasicShape::trace(visitor);
 }
 
-static String buildEllipseString(const String& radiusX, const String& radiusY, const String& centerX, const String& centerY, const String& box)
+static String buildEllipseString(const String& radiusX, const String& radiusY, const String& centerX, const String& centerY)
 {
     char at[] = "at";
     char separator[] = " ";
     StringBuilder result;
     result.appendLiteral("ellipse(");
     bool needsSeparator = false;
     if (!radiusX.isNull()) {
         result.append(radiusX);
         needsSeparator = true;
     }
     if (!radiusY.isNull()) {
         if (needsSeparator)
             result.appendLiteral(separator);
         result.append(radiusY);
         needsSeparator = true;
     }
 
     if (!centerX.isNull() || !centerY.isNull()) {
         if (needsSeparator)
             result.appendLiteral(separator);
         result.appendLiteral(at);
         result.appendLiteral(separator);
         result.append(centerX);
         result.appendLiteral(separator);
         result.append(centerY);
     }
     result.append(')');
-    if (box.length()) {
-        result.appendLiteral(separator);
-        result.append(box);
-    }
     return result.toString();
 }
 
 String CSSBasicShapeEllipse::cssText() const
 {
     RefPtrWillBeRawPtr<CSSPrimitiveValue> normalizedCX = buildSerializablePositionOffset(m_centerX, CSSValueLeft);
     RefPtrWillBeRawPtr<CSSPrimitiveValue> normalizedCY = buildSerializablePositionOffset(m_centerY, CSSValueTop);
 
     String radiusX;
     String radiusY;
     if (m_radiusX) {
         bool shouldSerializeRadiusXValue = m_radiusX->getValueID() != CSSValueClosestSide;
         bool shouldSerializeRadiusYValue = false;
 
         if (m_radiusY) {
             shouldSerializeRadiusYValue = m_radiusY->getValueID() != CSSValueClosestSide;
             if (shouldSerializeRadiusYValue)
                 radiusY = m_radiusY->cssText();
         }
         if (shouldSerializeRadiusXValue || (!shouldSerializeRadiusXValue && shouldSerializeRadiusYValue))
             radiusX = m_radiusX->cssText();
     }
 
     return buildEllipseString(radiusX, radiusY,
         serializePositionOffset(*normalizedCX->getPairValue(), *normalizedCY->getPairValue()),
-        serializePositionOffset(*normalizedCY->getPairValue(), *normalizedCX->getPairValue()),
-        m_referenceBox ? m_referenceBox->cssText() : String());
+        serializePositionOffset(*normalizedCY->getPairValue(), *normalizedCX->getPairValue()));
 }
 
 bool CSSBasicShapeEllipse::equals(const CSSBasicShape& shape) const
 {
     if (shape.type() != CSSBasicShapeEllipseType)
         return false;
 
     const CSSBasicShapeEllipse& other = toCSSBasicShapeEllipse(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_referenceBox, other.m_referenceBox);
+        && compareCSSValuePtr(m_radiusY, other.m_radiusY);
 }
 
 DEFINE_TRACE(CSSBasicShapeEllipse)
 {
     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& box)
+static String buildPolygonString(const WindRule& windRule, const Vector<String>& points)
 {
     ASSERT(!(points.size() % 2));
 
     StringBuilder result;
     const char evenOddOpening[] = "polygon(evenodd, ";
     const char nonZeroOpening[] = "polygon(";
     const char commaSeparator[] = ", ";
     static_assert(sizeof(evenOddOpening) > sizeof(nonZeroOpening), "polygon string openings should be the 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 (!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 (!box.isEmpty()) {
-        result.append(' ');
-        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_referenceBox ? m_referenceBox->cssText() : String());
+    return buildPolygonString(m_windRule, points);
 }
 
 bool CSSBasicShapePolygon::equals(const CSSBasicShape& shape) const
 {
     if (shape.type() != CSSBasicShapePolygonType)
         return false;
 
     const CSSBasicShapePolygon& rhs = toCSSBasicShapePolygon(shape);
-
-    if (!compareCSSValuePtr(m_referenceBox, rhs.m_referenceBox))
-        return false;
-
     return compareCSSValueVector(m_values, rhs.m_values);
 }
 
 DEFINE_TRACE(CSSBasicShapePolygon)
 {
     visitor->trace(m_values);
     CSSBasicShape::trace(visitor);
 }
 
 static bool buildInsetRadii(Vector<String> &radii, const String& topLeftRadius, const String& topRightRadius, const String& bottomRightRadius, const String& bottomLeftRadius)
@@ skipping 137 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 blink