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,
@@ skipping 14 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,
+  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 44 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;
+        !(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),
@@ skipping 221 matching lines @@
   visitor->trace(m_bottom);
   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