Changed Pair to be a CSSValue

Source/core/css/parser/CSSPropertyParser.cpp

 /*
  * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2012 Adobe Systems Incorporated. All rights reserved.
  * Copyright (C) 2012 Intel Corporation. All rights reserved.
  *
@@ skipping 34 matching lines @@
 #include "core/css/CSSPathValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSProperty.h"
 #include "core/css/CSSPropertyMetadata.h"
 #include "core/css/CSSQuadValue.h"
 #include "core/css/CSSReflectValue.h"
 #include "core/css/CSSSVGDocumentValue.h"
 #include "core/css/CSSShadowValue.h"
 #include "core/css/CSSTimingFunctionValue.h"
 #include "core/css/CSSUnicodeRangeValue.h"
+#include "core/css/CSSValuePair.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/HashTools.h"
-#include "core/css/Pair.h"
 #include "core/css/parser/CSSParserFastPaths.h"
 #include "core/css/parser/CSSParserValues.h"
 #include "core/frame/UseCounter.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/style/GridCoordinate.h"
 #include "core/svg/SVGPathUtilities.h"
 #include "platform/RuntimeEnabledFeatures.h"
 
 namespace blink {
 
 template <unsigned N>
 static bool equalIgnoringCase(const CSSParserString& a, const char (&b)[N])
 {
     unsigned length = N - 1; // Ignore the trailing null character
     if (a.length() != length)
         return false;
 
     return a.is8Bit() ? WTF::equalIgnoringCase(b, a.characters8(), length) : WTF::equalIgnoringCase(b, a.characters16(), length);
 }
 
-static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> createPrimitiveValuePair(PassRefPtrWillBeRawPtr<CSSPrimitiveValue> first, PassRefPtrWillBeRawPtr<CSSPrimitiveValue> second, Pair::IdenticalValuesPolicy identicalValuesPolicy = Pair::DropIdenticalValues)
+static PassRefPtrWillBeRawPtr<CSSValuePair> createCSSValuePair(PassRefPtrWillBeRawPtr<CSSValue> first, PassRefPtrWillBeRawPtr<CSSValue> second, CSSValuePair::IdenticalValuesPolicy identicalValuesPolicy = CSSValuePair::DropIdenticalValues)

[Timothy Loh, 2015/08/28 05:51:46]

I would probably just drop this function, all it does now is provide a default
value which would probably be better if it were explicit.

[sashab, 2015/08/31 00:33:51]

Was thinking the same thing actually. Done.

Should I add 'using CSSValuePair::DropIdenticalValues,
CSSValuePair::KeepIdenticalValues' so we don't have to use the prefix
everywhere?

[Timothy Loh, 2015/08/31 01:08:04]

It's probably fine to add the using statement to this file, but I think it's
slightly clearer without it.

[sashab, 2015/08/31 01:29:47]

Sure, just left it. Makes for some long lines in the file but there are some
ridiculously long lines in it anyway

 {
-    return cssValuePool().createValue(Pair::create(first, second, identicalValuesPolicy));
+    return CSSValuePair::create(first, second, identicalValuesPolicy);
 }
 
 CSSPropertyParser::CSSPropertyParser(CSSParserValueList* valueList,
     const CSSParserContext& context, WillBeHeapVector<CSSProperty, 256>& parsedProperties,
     StyleRule::Type ruleType)
     : m_valueList(valueList)
     , m_context(context)
     , m_parsedProperties(parsedProperties)
     , m_ruleType(ruleType)
     , m_inParseShorthand(0)
@@ skipping 889 matching lines @@
         if (value) {
             validPrimitive = validUnit(value, FLength | FPercent | FNonNeg);
             if (!validPrimitive)
                 return false;
             parsedValue2 = createPrimitiveNumericValue(value);
         } else
             parsedValue2 = parsedValue1;
 
         if (m_valueList->next())
             return false;
-        addProperty(propId, createPrimitiveValuePair(parsedValue1.release(), parsedValue2.release()), important);
+        addProperty(propId, createCSSValuePair(parsedValue1.release(), parsedValue2.release()), important);
         return true;
     }
     case CSSPropertyTabSize:
         // May be specified as a unit-less non-negative integer or length indicating number of space characters.
         validPrimitive = validUnit(value, FInteger | FLength | FNonNeg);
         break;
     case CSSPropertyBorderRadius:
     case CSSPropertyAliasWebkitBorderRadius:
         return parseBorderRadius(unresolvedProperty, important);
     case CSSPropertyOutlineOffset:
@@ skipping 1488 matching lines @@
     cumulativeFlags = 0;
     FillPositionFlag value4Flag = InvalidFillPosition;
     RefPtrWillBeRawPtr<CSSPrimitiveValue> value4 = parseFillPositionComponent(valueList, cumulativeFlags, value4Flag, ResolveValuesAsKeyword);
     if (!value4)
         return;
 
     // 4th value must be a length or a percentage.
     if (isFillPositionKeyword(value4->getValueID()))
         return;
 
-    value1 = createPrimitiveValuePair(parsedValue1, parsedValue2);
-    value2 = createPrimitiveValuePair(value3, value4);
+    value1 = createCSSValuePair(parsedValue1, parsedValue2);
+    value2 = createCSSValuePair(value3, value4);
 
     if (ident1 == CSSValueTop || ident1 == CSSValueBottom)
         value1.swap(value2);
 
     valueList->next();
 }
 void CSSPropertyParser::parse3ValuesFillPosition(CSSParserValueList* valueList, RefPtrWillBeRawPtr<CSSValue>& value1, RefPtrWillBeRawPtr<CSSValue>& value2, PassRefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue1, PassRefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue2)
 {
     unsigned cumulativeFlags = 0;
     FillPositionFlag value3Flag = InvalidFillPosition;
@@ skipping 20 matching lines @@
 
         // If 'center' is the first keyword then the last one needs to be a length.
         if (isFillPositionKeyword(ident3))
             return;
 
         firstPositionKeyword = CSSValueLeft;
         if (ident2 == CSSValueLeft || ident2 == CSSValueRight) {
             firstPositionKeyword = CSSValueTop;
             swapNeeded = true;
         }
-        value1 = createPrimitiveValuePair(cssValuePool().createIdentifierValue(firstPositionKeyword), cssValuePool().createValue(50, CSSPrimitiveValue::UnitType::Percentage));
-        value2 = createPrimitiveValuePair(parsedValue2, value3);
+        value1 = createCSSValuePair(cssValuePool().createIdentifierValue(firstPositionKeyword), cssValuePool().createValue(50, CSSPrimitiveValue::UnitType::Percentage));
+        value2 = createCSSValuePair(parsedValue2, value3);
     } else if (ident3 == CSSValueCenter) {
         if (isFillPositionKeyword(ident2))
             return;
 
         secondPositionKeyword = CSSValueTop;
         if (ident1 == CSSValueTop || ident1 == CSSValueBottom) {
             secondPositionKeyword = CSSValueLeft;
             swapNeeded = true;
         }
-        value1 = createPrimitiveValuePair(parsedValue1, parsedValue2);
-        value2 = createPrimitiveValuePair(cssValuePool().createIdentifierValue(secondPositionKeyword), cssValuePool().createValue(50, CSSPrimitiveValue::UnitType::Percentage));
+        value1 = createCSSValuePair(parsedValue1, parsedValue2);
+        value2 = createCSSValuePair(cssValuePool().createIdentifierValue(secondPositionKeyword), cssValuePool().createValue(50, CSSPrimitiveValue::UnitType::Percentage));
     } else {
         RefPtrWillBeRawPtr<CSSPrimitiveValue> firstPositionValue = nullptr;
         RefPtrWillBeRawPtr<CSSPrimitiveValue> secondPositionValue = nullptr;
 
         if (isFillPositionKeyword(ident2)) {
             // To match CSS grammar, we should only accept: [ center | left | right | bottom | top ] [ left | right | top | bottom ] [ <percentage> | <length> ].
             ASSERT(ident2 != CSSValueCenter);
 
             if (isFillPositionKeyword(ident3))
                 return;
 
             secondPositionValue = value3;
             secondPositionKeyword = ident2;
             firstPositionValue = cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Percentage);
         } else {
             // Per CSS, we should only accept: [ right | left | top | bottom ] [ <percentage> | <length> ] [ center | left | right | bottom | top ].
             if (!isFillPositionKeyword(ident3))
                 return;
 
             firstPositionValue = parsedValue2;
             secondPositionKeyword = ident3;
             secondPositionValue = cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Percentage);
         }
 
         if (isValueConflictingWithCurrentEdge(ident1, secondPositionKeyword))
             return;
 
-        value1 = createPrimitiveValuePair(parsedValue1, firstPositionValue);
-        value2 = createPrimitiveValuePair(cssValuePool().createIdentifierValue(secondPositionKeyword), secondPositionValue);
+        value1 = createCSSValuePair(parsedValue1, firstPositionValue);
+        value2 = createCSSValuePair(cssValuePool().createIdentifierValue(secondPositionKeyword), secondPositionValue);
     }
 
     if (ident1 == CSSValueTop || ident1 == CSSValueBottom || swapNeeded)
         value1.swap(value2);
 
 #if ENABLE(ASSERT)
-    CSSPrimitiveValue* first = toCSSPrimitiveValue(value1.get());
-    CSSPrimitiveValue* second = toCSSPrimitiveValue(value2.get());
-    ident1 = first->getPairValue()->first()->getValueID();
-    ident2 = second->getPairValue()->first()->getValueID();
+    const CSSValuePair* first = toCSSValuePair(value1.get());
+    const CSSValuePair* second = toCSSValuePair(value2.get());
+    ident1 = toCSSPrimitiveValue(first->first())->getValueID();
+    ident2 = toCSSPrimitiveValue(second->first())->getValueID();
     ASSERT(ident1 == CSSValueLeft || ident1 == CSSValueRight);
     ASSERT(ident2 == CSSValueBottom || ident2 == CSSValueTop);
 #endif
 }
 
 inline bool CSSPropertyParser::isPotentialPositionValue(CSSParserValue* value)
 {
     return isFillPositionKeyword(value->id) || validUnit(value, FPercent | FLength, ReleaseParsedCalcValue);
 }
 
@@ skipping 175 matching lines @@
     } else if (unresolvedProperty == CSSPropertyAliasWebkitBackgroundSize) {
         // For backwards compatibility we set the second value to the first if it is omitted.
         // We only need to do this for -webkit-background-size. It should be safe to let masks match
         // the real property.
         parsedValue2 = parsedValue1;
     }
 
     if (!parsedValue2)
         return parsedValue1;
 
-    return createPrimitiveValuePair(parsedValue1.release(), parsedValue2.release(), Pair::KeepIdenticalValues);
+    return createCSSValuePair(parsedValue1.release(), parsedValue2.release(), CSSValuePair::KeepIdenticalValues);
 }
 
 bool CSSPropertyParser::parseFillProperty(CSSPropertyID propId, CSSPropertyID& propId1, CSSPropertyID& propId2,
     RefPtrWillBeRawPtr<CSSValue>& retValue1, RefPtrWillBeRawPtr<CSSValue>& retValue2)
 {
     // We initially store the first value in value/value2, and only create
     // CSSValueLists if we have more values.
     RefPtrWillBeRawPtr<CSSValueList> values = nullptr;
     RefPtrWillBeRawPtr<CSSValueList> values2 = nullptr;
     RefPtrWillBeRawPtr<CSSValue> value = nullptr;
@@ skipping 1292 matching lines @@
             radii[1][i - indexAfterSlash] = radius.release();
     }
 
     if (!indexAfterSlash) {
         completeBorderRadii(radii[0]);
         for (unsigned i = 0; i < 4; ++i)
             radii[1][i] = radii[0][i];
     } else {
         completeBorderRadii(radii[1]);
     }
-    shape->setTopLeftRadius(createPrimitiveValuePair(radii[0][0].release(), radii[1][0].release()));
-    shape->setTopRightRadius(createPrimitiveValuePair(radii[0][1].release(), radii[1][1].release()));
-    shape->setBottomRightRadius(createPrimitiveValuePair(radii[0][2].release(), radii[1][2].release()));
-    shape->setBottomLeftRadius(createPrimitiveValuePair(radii[0][3].release(), radii[1][3].release()));
+    shape->setTopLeftRadius(createCSSValuePair(radii[0][0].release(), radii[1][0].release()));
+    shape->setTopRightRadius(createCSSValuePair(radii[0][1].release(), radii[1][1].release()));
+    shape->setBottomRightRadius(createCSSValuePair(radii[0][2].release(), radii[1][2].release()));
+    shape->setBottomLeftRadius(createCSSValuePair(radii[0][3].release(), radii[1][3].release()));
 
     return shape;
 }
 
 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapeInset(CSSParserValueList* args)
 {
     ASSERT(args);
 
     RefPtrWillBeRawPtr<CSSBasicShapeInset> shape = CSSBasicShapeInset::create();
 
@@ skipping 84 matching lines @@
             return false;
         if (value->id != CSSValueCenter && value->id != CSSValueLeft && value->id != CSSValueRight)
             return false;
     } else if (value->id == CSSValueCenter || value->id == CSSValueLeft || value->id == CSSValueRight) {
         if (!m_valueList->next() || m_valueList->current()->id != CSSValueLegacy)
             return false;
     } else {
         return false;
     }
 
-    addProperty(propId, createPrimitiveValuePair(cssValuePool().createIdentifierValue(CSSValueLegacy), cssValuePool().createIdentifierValue(value->id)), important);
+    addProperty(propId, createCSSValuePair(cssValuePool().createIdentifierValue(CSSValueLegacy), cssValuePool().createIdentifierValue(value->id)), important);
     return !m_valueList->next();
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseContentDistributionOverflowPosition()
 {
     // auto | <baseline-position> | <content-distribution> || [ <overflow-position>? && <content-position> ]
     // <baseline-position> = baseline | last-baseline;
     // <content-distribution> = space-between | space-around | space-evenly | stretch;
     // <content-position> = center | start | end | flex-start | flex-end | left | right;
     // <overflow-position> = true | safe
@@ skipping 77 matching lines @@
             return false;
     } else {
         return false;
     }
 
     if (m_valueList->next())
         return false;
 
     ASSERT(position);
     if (overflowAlignmentKeyword)
-        addProperty(propId, createPrimitiveValuePair(position, overflowAlignmentKeyword), important);
+        addProperty(propId, createCSSValuePair(position, overflowAlignmentKeyword), important);
     else
         addProperty(propId, position.release(), important);
 
     return true;
 }
 
 PassRefPtrWillBeRawPtr<CSSPrimitiveValue> CSSPropertyParser::parseShapeRadius(CSSParserValue* value)
 {
     if (value->id == CSSValueClosestSide || value->id == CSSValueFarthestSide)
         return cssValuePool().createIdentifierValue(value->id);
@@ skipping 28 matching lines @@
             }
 
             return nullptr;
         }
 
         if (argument->id == CSSValueAt && args->next()) {
             RefPtrWillBeRawPtr<CSSValue> centerX = nullptr;
             RefPtrWillBeRawPtr<CSSValue> centerY = nullptr;
             parseFillPosition(args, centerX, centerY);
             if (centerX && centerY && !args->current()) {
-                ASSERT(centerX->isPrimitiveValue());
-                ASSERT(centerY->isPrimitiveValue());
-                shape->setCenterX(toCSSPrimitiveValue(centerX.get()));
-                shape->setCenterY(toCSSPrimitiveValue(centerY.get()));
+                shape->setCenterX(centerX);
+                shape->setCenterY(centerY);
             } else {
                 return nullptr;
             }
         } else {
             return nullptr;
         }
     }
 
     return shape;
 }
@@ skipping 30 matching lines @@
         }
 
         if (argument->id != CSSValueAt || !args->next()) // expecting ellipse(.. at <position>)
             return nullptr;
         RefPtrWillBeRawPtr<CSSValue> centerX = nullptr;
         RefPtrWillBeRawPtr<CSSValue> centerY = nullptr;
         parseFillPosition(args, centerX, centerY);
         if (!centerX || !centerY || args->current())
             return nullptr;
 
-        ASSERT(centerX->isPrimitiveValue());
-        ASSERT(centerY->isPrimitiveValue());
-        shape->setCenterX(toCSSPrimitiveValue(centerX.get()));
-        shape->setCenterY(toCSSPrimitiveValue(centerY.get()));
+        shape->setCenterX(centerX);
+        shape->setCenterY(centerY);
     }
 
     return shape;
 }
 
 PassRefPtrWillBeRawPtr<CSSBasicShape> CSSPropertyParser::parseBasicShapePolygon(CSSParserValueList* args)
 {
     ASSERT(args);
 
     unsigned size = args->size();
@@ skipping 979 matching lines @@
     return true;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parsePosition(CSSParserValueList* valueList)
 {
     RefPtrWillBeRawPtr<CSSValue> xValue = nullptr;
     RefPtrWillBeRawPtr<CSSValue> yValue = nullptr;
     parseFillPosition(valueList, xValue, yValue);
     if (!xValue || !yValue)
         return nullptr;
-    return createPrimitiveValuePair(toCSSPrimitiveValue(xValue.get()), toCSSPrimitiveValue(yValue.get()), Pair::KeepIdenticalValues);
+    return createCSSValuePair(xValue.release(), yValue.release(), CSSValuePair::KeepIdenticalValues);
 }
 
 // Parses a list of comma separated positions. i.e., <position>#
 PassRefPtrWillBeRawPtr<CSSValueList> CSSPropertyParser::parsePositionList(CSSParserValueList* valueList)
 {
     RefPtrWillBeRawPtr<CSSValueList> positions = CSSValueList::createCommaSeparated();
     while (true) {
         // parsePosition consumes values until it reaches a separator [,/],
         // an invalid token, or end of the list
         RefPtrWillBeRawPtr<CSSValue> position = parsePosition(valueList);
@@ skipping 269 matching lines @@
             return false;
         } else {
             // We need to rewind the value list, so that when its advanced we'll
             // end up back at this value.
             m_valueList->previous();
             secondValue = firstValue;
         }
     } else
         secondValue = firstValue;
 
-    result = createPrimitiveValuePair(firstValue, secondValue);
+    result = createCSSValuePair(firstValue, secondValue);
     return true;
 }
 
 class BorderImageSliceParseContext {
     STACK_ALLOCATED();
 public:
     BorderImageSliceParseContext()
     : m_allowNumber(true)
     , m_allowFill(true)
     , m_allowFinalCommit(false)
@@ skipping 237 matching lines @@
     }
 
     if (!indexAfterSlash) {
         completeBorderRadii(radii[0]);
         for (unsigned i = 0; i < 4; ++i)
             radii[1][i] = radii[0][i];
     } else
         completeBorderRadii(radii[1]);
 
     ImplicitScope implicitScope(this);
-    addProperty(CSSPropertyBorderTopLeftRadius, createPrimitiveValuePair(radii[0][0].release(), radii[1][0].release()), important);
-    addProperty(CSSPropertyBorderTopRightRadius, createPrimitiveValuePair(radii[0][1].release(), radii[1][1].release()), important);
-    addProperty(CSSPropertyBorderBottomRightRadius, createPrimitiveValuePair(radii[0][2].release(), radii[1][2].release()), important);
-    addProperty(CSSPropertyBorderBottomLeftRadius, createPrimitiveValuePair(radii[0][3].release(), radii[1][3].release()), important);
+    addProperty(CSSPropertyBorderTopLeftRadius, createCSSValuePair(radii[0][0].release(), radii[1][0].release()), important);
+    addProperty(CSSPropertyBorderTopRightRadius, createCSSValuePair(radii[0][1].release(), radii[1][1].release()), important);
+    addProperty(CSSPropertyBorderBottomRightRadius, createCSSValuePair(radii[0][2].release(), radii[1][2].release()), important);
+    addProperty(CSSPropertyBorderBottomLeftRadius, createCSSValuePair(radii[0][3].release(), radii[1][3].release()), important);
     return true;
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::parseCounter(int defaultValue)
 {
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
 
     while (m_valueList->current()) {
         CSSParserValue* val = m_valueList->current();
         if (val->m_unit != CSSParserValue::Identifier)
             return nullptr;
         RefPtrWillBeRawPtr<CSSPrimitiveValue> counterName = createPrimitiveCustomIdentValue(val);
         m_valueList->next();
 
         val = m_valueList->current();
         int i = defaultValue;
         if (val && validUnit(val, FInteger)) {
             i = clampTo<int>(val->fValue);
             m_valueList->next();
         }
 
-        list->append(createPrimitiveValuePair(counterName.release(),
+        list->append(createCSSValuePair(counterName.release(),
             cssValuePool().createValue(i, CSSPrimitiveValue::UnitType::Number)));
     }
 
     if (!list->length())
         return nullptr;
     return list.release();
 }
 
 // This should go away once we drop support for -webkit-gradient
 static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> parseDeprecatedGradientPoint(CSSParserValue* a, bool horizontal)
@@ skipping 585 matching lines @@
         if (!a)
             return false;
 
         parseFillPosition(args, centerX, centerY);
         if (!(centerX && centerY))
             return false;
 
         a = args->current();
         if (!a)
             return false;
-        result->setFirstX(toCSSPrimitiveValue(centerX.get()));
-        result->setFirstY(toCSSPrimitiveValue(centerY.get()));
+        result->setFirstX(centerX);
+        result->setFirstY(centerY);
         // Right now, CSS radial gradients have the same start and end centers.
-        result->setSecondX(toCSSPrimitiveValue(centerX.get()));
-        result->setSecondY(toCSSPrimitiveValue(centerY.get()));
+        result->setSecondX(centerX);
+        result->setSecondY(centerY);
     }
 
     if (shapeValue || sizeValue || horizontalSize || centerX || centerY)
         expectComma = true;
 
     if (!parseGradientColorStops(args, result.get(), expectComma))
         return false;
 
     gradient = result.release();
     return true;
@@ skipping 1485 matching lines @@
         }
     }
 
     if (!list->length())
         return nullptr;
 
     return list.release();
 }
 
 } // namespace blink