Split CSSPrimitiveValue into CSSPrimitiveValue and CSSIdentifierValue

third_party/WebKit/Source/core/css/CSSBasicShapeValues.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 11 matching lines @@
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * 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.
  */
 
 #include "core/css/CSSBasicShapeValues.h"
 
+#include "core/css/CSSIdentifierValue.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/css/CSSValuePair.h"
 #include "platform/Length.h"
 #include "wtf/text/StringBuilder.h"
 
 using namespace WTF;
 
 namespace blink {
 
 static String buildCircleString(const String& radius, const String& centerX, const String& centerY)
@@ skipping 13 matching lines @@
         result.append(centerX);
         result.append(separator);
         result.append(centerY);
     }
     result.append(')');
     return result.toString();
 }
 
 static String serializePositionOffset(const CSSValuePair& offset, const CSSValuePair& other)
 {
-    if ((toCSSPrimitiveValue(offset.first()).getValueID() == CSSValueLeft && toCSSPrimitiveValue(other.first()).getValueID() == CSSValueTop)
-        || (toCSSPrimitiveValue(offset.first()).getValueID() == CSSValueTop && toCSSPrimitiveValue(other.first()).getValueID() == CSSValueLeft))
+    if ((toCSSIdentifierValue(offset.first()).getValueID() == CSSValueLeft && toCSSIdentifierValue(other.first()).getValueID() == CSSValueTop)
+        || (toCSSIdentifierValue(offset.first()).getValueID() == CSSValueTop && toCSSIdentifierValue(other.first()).getValueID() == CSSValueLeft))
         return offset.second().cssText();
     return offset.cssText();
 }
 
 static CSSValuePair* buildSerializablePositionOffset(CSSValue* offset, CSSValueID defaultSide)
 {
     CSSValueID side = defaultSide;
     const CSSPrimitiveValue* amount = nullptr;
 
     if (!offset) {
         side = CSSValueCenter;
-    } else if (offset->isPrimitiveValue() && toCSSPrimitiveValue(offset)->isValueID()) {
-        side = toCSSPrimitiveValue(offset)->getValueID();
+    } else if (offset->isIdentifierValue()) {
+        side = toCSSIdentifierValue(offset)->getValueID();
     } else if (offset->isValuePair()) {
-        side = toCSSPrimitiveValue(toCSSValuePair(*offset).first()).getValueID();
+        side = toCSSIdentifierValue(toCSSValuePair(*offset).first()).getValueID();
         amount = &toCSSPrimitiveValue(toCSSValuePair(*offset).second());
         if ((side == CSSValueRight || side == CSSValueBottom) && amount->isPercentage()) {
             side = defaultSide;
             amount = CSSPrimitiveValue::create(100 - amount->getFloatValue(), CSSPrimitiveValue::UnitType::Percentage);
         }
     } else {
         amount = toCSSPrimitiveValue(offset);
     }
 
     if (side == CSSValueCenter) {
         side = defaultSide;
         amount = CSSPrimitiveValue::create(50, CSSPrimitiveValue::UnitType::Percentage);
     } else if (!amount || (amount->isLength() && !amount->getFloatValue())) {
         if (side == CSSValueRight || side == CSSValueBottom)
             amount = CSSPrimitiveValue::create(100, CSSPrimitiveValue::UnitType::Percentage);
         else
             amount = CSSPrimitiveValue::create(0, CSSPrimitiveValue::UnitType::Percentage);
         side = defaultSide;
     }
 
-    return CSSValuePair::create(CSSPrimitiveValue::createIdentifier(side), amount, CSSValuePair::KeepIdenticalValues);
+    return CSSValuePair::create(CSSIdentifierValue::create(side), amount, CSSValuePair::KeepIdenticalValues);
 }
 
 String CSSBasicShapeCircleValue::customCSSText() const
 {
     CSSValuePair* normalizedCX = buildSerializablePositionOffset(m_centerX, CSSValueLeft);
     CSSValuePair* normalizedCY = buildSerializablePositionOffset(m_centerY, CSSValueTop);
 
     String radius;
-    if (m_radius && m_radius->getValueID() != CSSValueClosestSide)
+    if (m_radius && !(m_radius->isIdentifierValue() && toCSSIdentifierValue(*m_radius).getValueID() == CSSValueClosestSide))
         radius = m_radius->cssText();
 
     return buildCircleString(radius,
         serializePositionOffset(*normalizedCX, *normalizedCY),
         serializePositionOffset(*normalizedCY, *normalizedCX));
 }
 
 bool CSSBasicShapeCircleValue::equals(const CSSBasicShapeCircleValue& other) const
 {
     return compareCSSValuePtr(m_centerX, other.m_centerX)
@@ skipping 41 matching lines @@
 }
 
 String CSSBasicShapeEllipseValue::customCSSText() const
 {
     CSSValuePair* normalizedCX = buildSerializablePositionOffset(m_centerX, CSSValueLeft);
     CSSValuePair* normalizedCY = buildSerializablePositionOffset(m_centerY, CSSValueTop);
 
     String radiusX;
     String radiusY;
     if (m_radiusX) {
-        bool shouldSerializeRadiusXValue = m_radiusX->getValueID() != CSSValueClosestSide;
+        bool shouldSerializeRadiusXValue = !(m_radiusX->isIdentifierValue() && toCSSIdentifierValue(*m_radiusX).getValueID() == CSSValueClosestSide);
         bool shouldSerializeRadiusYValue = false;
 
         if (m_radiusY) {
-            shouldSerializeRadiusYValue = m_radiusY->getValueID() != CSSValueClosestSide;
+            shouldSerializeRadiusYValue = !(m_radiusY->isIdentifierValue() && toCSSIdentifierValue(*m_radiusY).getValueID() == CSSValueClosestSide);
             if (shouldSerializeRadiusYValue)
                 radiusY = m_radiusY->cssText();
         }
         if (shouldSerializeRadiusXValue || (!shouldSerializeRadiusXValue && shouldSerializeRadiusYValue))
             radiusX = m_radiusX->cssText();
     }
 
     return buildEllipseString(radiusX, radiusY,
         serializePositionOffset(*normalizedCX, *normalizedCY),
         serializePositionOffset(*normalizedCY, *normalizedCX));
@@ skipping 210 matching lines @@
     visitor->trace(m_left);
     visitor->trace(m_topLeftRadius);
     visitor->trace(m_topRightRadius);
     visitor->trace(m_bottomRightRadius);
     visitor->trace(m_bottomLeftRadius);
     CSSValue::traceAfterDispatch(visitor);
 }
 
 } // namespace blink