Split CSSPrimitiveValue into CSSPrimitiveValue and CSSIdentifierValue

third_party/WebKit/Source/core/css/parser/CSSPropertyParserHelpers.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/parser/CSSPropertyParserHelpers.h"
 
 #include "core/css/CSSCalculationValue.h"
 #include "core/css/CSSColorValue.h"
 #include "core/css/CSSCrossfadeValue.h"
 #include "core/css/CSSGradientValue.h"
@@ skipping 279 matching lines @@
         return nullptr;
     }
     CalcParser calcParser(range, valueRange);
     if (const CSSCalcValue* calculation = calcParser.value()) {
         if (calculation->category() == CalcTime)
             return calcParser.consumeValue();
     }
     return nullptr;
 }
 
-CSSPrimitiveValue* consumeIdent(CSSParserTokenRange& range)
+CSSIdentifierValue* consumeIdent(CSSParserTokenRange& range)
 {
     if (range.peek().type() != IdentToken)
         return nullptr;
-    return CSSPrimitiveValue::createIdentifier(range.consumeIncludingWhitespace().id());
+    return CSSIdentifierValue::create(range.consumeIncludingWhitespace().id());
 }
 
-CSSPrimitiveValue* consumeIdentRange(CSSParserTokenRange& range, CSSValueID lower, CSSValueID upper)
+CSSIdentifierValue* consumeIdentRange(CSSParserTokenRange& range, CSSValueID lower, CSSValueID upper)
 {
     if (range.peek().id() < lower || range.peek().id() > upper)
         return nullptr;
     return consumeIdent(range);
 }
 
 CSSCustomIdentValue* consumeCustomIdent(CSSParserTokenRange& range)
 {
     if (range.peek().type() != IdentToken || isCSSWideKeyword(range.peek().value()))
         return nullptr;
@@ skipping 165 matching lines @@
         if (!isValueAllowedInMode(id, cssParserMode))
             return nullptr;
         return consumeIdent(range);
     }
     RGBA32 color = Color::transparent;
     if (!parseHexColor(range, color, acceptQuirkyColors) && !parseColorFunction(range, color))
         return nullptr;
     return CSSColorValue::create(color);
 }
 
-static CSSPrimitiveValue* consumePositionComponent(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless, bool& horizontalEdge, bool& verticalEdge)
+static CSSValue* consumePositionComponent(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless, bool& horizontalEdge, bool& verticalEdge)
 {
     if (range.peek().type() != IdentToken)
         return consumeLengthOrPercent(range, cssParserMode, ValueRangeAll, unitless);
 
     CSSValueID id = range.peek().id();
     if (id == CSSValueLeft || id == CSSValueRight) {
         if (horizontalEdge)
             return nullptr;
         horizontalEdge = true;
     } else if (id == CSSValueTop || id == CSSValueBottom) {
         if (verticalEdge)
             return nullptr;
         verticalEdge = true;
     } else if (id != CSSValueCenter) {
         return nullptr;
     }
     return consumeIdent(range);
 }
 
-static bool isHorizontalPositionKeywordOnly(const CSSPrimitiveValue& value)
+static bool isHorizontalPositionKeywordOnly(const CSSValue& value)
 {
-    return value.isValueID() && (value.getValueID() == CSSValueLeft || value.getValueID() == CSSValueRight);
+    if (!value.isIdentifierValue())
+        return false;
+    CSSValueID valueID = toCSSIdentifierValue(value).getValueID();
+    return valueID == CSSValueLeft || valueID == CSSValueRight;
 }
 
-static bool isVerticalPositionKeywordOnly(const CSSPrimitiveValue& value)
+static bool isVerticalPositionKeywordOnly(const CSSValue& value)
 {
-    return value.isValueID() && (value.getValueID() == CSSValueTop || value.getValueID() == CSSValueBottom);
+    if (!value.isIdentifierValue())
+        return false;
+    CSSValueID valueID = toCSSIdentifierValue(value).getValueID();
+    return valueID == CSSValueTop || valueID == CSSValueBottom;
 }
 
-static void positionFromOneValue(CSSPrimitiveValue* value, CSSValue*& resultX, CSSValue*& resultY)
+static void positionFromOneValue(CSSValue* value, CSSValue*& resultX, CSSValue*& resultY)
 {
     bool valueAppliesToYAxisOnly = isVerticalPositionKeywordOnly(*value);
     resultX = value;
-    resultY = CSSPrimitiveValue::createIdentifier(CSSValueCenter);
+    resultY = CSSIdentifierValue::create(CSSValueCenter);
     if (valueAppliesToYAxisOnly)
         std::swap(resultX, resultY);
 }
 
-static void positionFromTwoValues(CSSPrimitiveValue* value1, CSSPrimitiveValue* value2,
+static void positionFromTwoValues(CSSValue* value1, CSSValue* value2,
     CSSValue*& resultX, CSSValue*& resultY)
 {
     bool mustOrderAsXY = isHorizontalPositionKeywordOnly(*value1) || isVerticalPositionKeywordOnly(*value2)
-        || !value1->isValueID() || !value2->isValueID();
+        || !value1->isIdentifierValue() || !value2->isIdentifierValue();
     bool mustOrderAsYX = isVerticalPositionKeywordOnly(*value1) || isHorizontalPositionKeywordOnly(*value2);
     DCHECK(!mustOrderAsXY || !mustOrderAsYX);
     resultX = value1;
     resultY = value2;
     if (mustOrderAsYX)
         std::swap(resultX, resultY);
 }
 
-static void positionFromThreeOrFourValues(CSSPrimitiveValue** values, CSSValue*& resultX, CSSValue*& resultY)
+static void positionFromThreeOrFourValues(CSSValue** values, CSSValue*& resultX, CSSValue*& resultY)
 {
-    CSSPrimitiveValue* center = nullptr;
+    CSSIdentifierValue* center = nullptr;
     for (int i = 0; values[i]; i++) {
-        CSSPrimitiveValue* currentValue = values[i];
-        DCHECK(currentValue->isValueID());
+        CSSIdentifierValue* currentValue = toCSSIdentifierValue(values[i]);
         CSSValueID id = currentValue->getValueID();
 
         if (id == CSSValueCenter) {
             DCHECK(!center);
             center = currentValue;
             continue;
         }
 
         CSSValue* result = nullptr;
-        if (values[i + 1] && !values[i + 1]->isValueID()) {
+        if (values[i + 1] && !values[i + 1]->isIdentifierValue()) {
             result = CSSValuePair::create(currentValue, values[++i], CSSValuePair::KeepIdenticalValues);
         } else {
             result = currentValue;
         }
 
         if (id == CSSValueLeft || id == CSSValueRight) {
             DCHECK(!resultX);
             resultX = result;
         } else {
             DCHECK(id == CSSValueTop || id == CSSValueBottom);
@@ skipping 10 matching lines @@
             resultY = center;
     }
 
     DCHECK(resultX && resultY);
 }
 
 bool consumePosition(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless, CSSValue*& resultX, CSSValue*& resultY)
 {
     bool horizontalEdge = false;
     bool verticalEdge = false;
-    CSSPrimitiveValue* value1 = consumePositionComponent(range, cssParserMode, unitless, horizontalEdge, verticalEdge);
+    CSSValue* value1 = consumePositionComponent(range, cssParserMode, unitless, horizontalEdge, verticalEdge);
     if (!value1)
         return false;
-    if (!value1->isValueID())
+    if (!value1->isIdentifierValue())
         horizontalEdge = true;
 
     CSSParserTokenRange rangeAfterFirstConsume = range;
-    CSSPrimitiveValue* value2 = consumePositionComponent(range, cssParserMode, unitless, horizontalEdge, verticalEdge);
+    CSSValue* value2 = consumePositionComponent(range, cssParserMode, unitless, horizontalEdge, verticalEdge);
     if (!value2) {
         positionFromOneValue(value1, resultX, resultY);
         return true;
     }
 
-    CSSPrimitiveValue* value3 = nullptr;
-    if (value1->isValueID()
-        && value2->isValueID() != (range.peek().type() == IdentToken)
-        && (value2->isValueID() ? value2->getValueID() : value1->getValueID()) != CSSValueCenter)
+    CSSValue* value3 = nullptr;
+    if (value1->isIdentifierValue()
+        && value2->isIdentifierValue() != (range.peek().type() == IdentToken)
+        && (value2->isIdentifierValue() ? toCSSIdentifierValue(value2)->getValueID() : toCSSIdentifierValue(value1)->getValueID()) != CSSValueCenter)
         value3 = consumePositionComponent(range, cssParserMode, unitless, horizontalEdge, verticalEdge);
     if (!value3) {
-        if (verticalEdge && !value2->isValueID()) {
+        if (verticalEdge && !value2->isIdentifierValue()) {
             range = rangeAfterFirstConsume;
             positionFromOneValue(value1, resultX, resultY);
             return true;
         }
         positionFromTwoValues(value1, value2, resultX, resultY);
         return true;
     }
 
-    CSSPrimitiveValue* value4 = nullptr;
-    if (value3->isValueID() && value3->getValueID() != CSSValueCenter && range.peek().type() != IdentToken)
+    CSSValue* value4 = nullptr;
+    if (value3->isIdentifierValue() && toCSSIdentifierValue(value3)->getValueID() != CSSValueCenter && range.peek().type() != IdentToken)
         value4 = consumePositionComponent(range, cssParserMode, unitless, horizontalEdge, verticalEdge);
-    CSSPrimitiveValue* values[5];
+    CSSValue* values[5];
     values[0] = value1;
     values[1] = value2;
     values[2] = value3;
     values[3] = value4;
     values[4] = nullptr;
     positionFromThreeOrFourValues(values, resultX, resultY);
     return true;
 }
 
 CSSValuePair* consumePosition(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
 {
     CSSValue* resultX = nullptr;
     CSSValue* resultY = nullptr;
     if (consumePosition(range, cssParserMode, unitless, resultX, resultY))
         return CSSValuePair::create(resultX, resultY, CSSValuePair::KeepIdenticalValues);
     return nullptr;
 }
 
 bool consumeOneOrTwoValuedPosition(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless, CSSValue*& resultX, CSSValue*& resultY)
 {
     bool horizontalEdge = false;
     bool verticalEdge = false;
-    CSSPrimitiveValue* value1 = consumePositionComponent(range, cssParserMode, unitless, horizontalEdge, verticalEdge);
+    CSSValue* value1 = consumePositionComponent(range, cssParserMode, unitless, horizontalEdge, verticalEdge);
     if (!value1)
         return false;
-    if (!value1->isValueID())
+    if (!value1->isIdentifierValue())
         horizontalEdge = true;
 
-    CSSPrimitiveValue* value2 = nullptr;
+    CSSValue* value2 = nullptr;
     if (!verticalEdge || range.peek().type() == IdentToken)
         value2 = consumePositionComponent(range, cssParserMode, unitless, horizontalEdge, verticalEdge);
     if (!value2) {
         positionFromOneValue(value1, resultX, resultY);
         return true;
     }
     positionFromTwoValues(value1, value2, resultX, resultY);
     return true;
 }
 
@@ skipping 142 matching lines @@
 
 static CSSValue* consumeDeprecatedRadialGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating)
 {
     CSSRadialGradientValue* result = CSSRadialGradientValue::create(repeating, CSSPrefixedRadialGradient);
     CSSValue* centerX = nullptr;
     CSSValue* centerY = nullptr;
     consumeOneOrTwoValuedPosition(args, cssParserMode, UnitlessQuirk::Forbid, centerX, centerY);
     if ((centerX || centerY) && !consumeCommaIncludingWhitespace(args))
         return nullptr;
 
-    result->setFirstX(toCSSPrimitiveValue(centerX));
-    result->setSecondX(toCSSPrimitiveValue(centerX));
-    result->setFirstY(toCSSPrimitiveValue(centerY));
-    result->setSecondY(toCSSPrimitiveValue(centerY));
+    result->setFirstX(centerX);
+    result->setSecondX(centerX);
+    result->setFirstY(centerY);
+    result->setSecondY(centerY);
 
-    CSSPrimitiveValue* shape = consumeIdent<CSSValueCircle, CSSValueEllipse>(args);
-    CSSPrimitiveValue* sizeKeyword = consumeIdent<CSSValueClosestSide, CSSValueClosestCorner, CSSValueFarthestSide, CSSValueFarthestCorner, CSSValueContain, CSSValueCover>(args);
+    CSSIdentifierValue* shape = consumeIdent<CSSValueCircle, CSSValueEllipse>(args);
+    CSSIdentifierValue* sizeKeyword = consumeIdent<CSSValueClosestSide, CSSValueClosestCorner, CSSValueFarthestSide, CSSValueFarthestCorner, CSSValueContain, CSSValueCover>(args);
     if (!shape)
         shape = consumeIdent<CSSValueCircle, CSSValueEllipse>(args);
     result->setShape(shape);
     result->setSizingBehavior(sizeKeyword);
 
     // Or, two lengths or percentages
     if (!shape && !sizeKeyword) {
         CSSPrimitiveValue* horizontalSize = consumeLengthOrPercent(args, cssParserMode, ValueRangeAll);
         CSSPrimitiveValue* verticalSize = nullptr;
         if (horizontalSize) {
@@ skipping 10 matching lines @@
     if (!consumeGradientColorStops(args, cssParserMode, result))
         return nullptr;
 
     return result;
 }
 
 static CSSValue* consumeRadialGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating)
 {
     CSSRadialGradientValue* result = CSSRadialGradientValue::create(repeating, CSSRadialGradient);
 
-    CSSPrimitiveValue* shape = nullptr;
-    CSSPrimitiveValue* sizeKeyword = nullptr;
+    CSSIdentifierValue* shape = nullptr;
+    CSSIdentifierValue* sizeKeyword = nullptr;
     CSSPrimitiveValue* horizontalSize = nullptr;
     CSSPrimitiveValue* verticalSize = nullptr;
 
     // First part of grammar, the size/shape clause:
     // [ circle || <length> ] |
     // [ ellipse || [ <length> | <percentage> ]{2} ] |
     // [ [ circle | ellipse] || <size-keyword> ]
     for (int i = 0; i < 3; ++i) {
         if (args.peek().type() == IdentToken) {
             CSSValueID id = args.peek().id();
@@ skipping 67 matching lines @@
 
 static CSSValue* consumeLinearGradient(CSSParserTokenRange& args, CSSParserMode cssParserMode, CSSGradientRepeat repeating, CSSGradientType gradientType)
 {
     CSSLinearGradientValue* result = CSSLinearGradientValue::create(repeating, gradientType);
 
     bool expectComma = true;
     CSSPrimitiveValue* angle = consumeAngle(args);
     if (angle) {
         result->setAngle(angle);
     } else if (gradientType == CSSPrefixedLinearGradient || consumeIdent<CSSValueTo>(args)) {
-        CSSPrimitiveValue* endX = consumeIdent<CSSValueLeft, CSSValueRight>(args);
-        CSSPrimitiveValue* endY = consumeIdent<CSSValueBottom, CSSValueTop>(args);
+        CSSIdentifierValue* endX = consumeIdent<CSSValueLeft, CSSValueRight>(args);
+        CSSIdentifierValue* endY = consumeIdent<CSSValueBottom, CSSValueTop>(args);
         if (!endX && !endY) {
             if (gradientType == CSSLinearGradient)
                 return nullptr;
-            endY = CSSPrimitiveValue::createIdentifier(CSSValueTop);
+            endY = CSSIdentifierValue::create(CSSValueTop);
             expectComma = false;
         } else if (!endX) {
             endX = consumeIdent<CSSValueLeft, CSSValueRight>(args);
         }
 
         result->setFirstX(endX);
         result->setFirstY(endY);
     } else {
         expectComma = false;
     }
@@ skipping 158 matching lines @@
 {
     return equalIgnoringASCIICase(keyword, "initial")
         || equalIgnoringASCIICase(keyword, "inherit")
         || equalIgnoringASCIICase(keyword, "unset")
         || equalIgnoringASCIICase(keyword, "default");
 }
 
 } // namespace CSSPropertyParserHelpers
 
 } // namespace blink