CSSValue Immediates: Replace CSSPrimitiveValue usage with const references

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 57 matching lines @@
 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 CSSPrimitiveValue createPrimitiveValuePair(CSSPrimitiveValue first, CSSPrimitiveValue second, Pair::IdenticalValuesPolicy identicalValuesPolicy = Pair::DropIdenticalValues)
+static CSSPrimitiveValue createPrimitiveValuePair(const CSSPrimitiveValue& first, const CSSPrimitiveValue& second, Pair::IdenticalValuesPolicy identicalValuesPolicy = Pair::DropIdenticalValues)
 {
     return cssValuePool().createValue(Pair::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)
@@ skipping 26 matching lines @@
     // This doesn't count UA style sheets
     if (parseSuccess && context.useCounter())
         context.useCounter()->count(context, unresolvedProperty);
 
     if (!parseSuccess)
         parser.rollbackLastProperties(parsedProperties.size() - parsedPropertiesSize);
 
     return parseSuccess;
 }
 
-void CSSPropertyParser::addProperty(CSSPropertyID propId, CSSValue value, bool important, bool implicit)
+void CSSPropertyParser::addProperty(CSSPropertyID propId, const CSSValue& value, bool important, bool implicit)
 {
     ASSERT(!isPropertyAlias(propId));
 
     int shorthandIndex = 0;
     bool setFromShorthand = false;
 
     if (m_currentShorthand) {
         Vector<StylePropertyShorthand, 4> shorthands;
         getMatchingShorthandsForLonghand(propId, &shorthands);
         // Viewport descriptors have width and height as shorthands, but it doesn't
@@ skipping 376 matching lines @@
         if (m_valueList->size() != 1)
             return false;
         return parseFontWeight(important);
     }
 
     case CSSPropertyBorderSpacing: {
         if (num == 1) {
             ShorthandScope scope(this, CSSPropertyBorderSpacing);
             if (!parseValue(CSSPropertyWebkitBorderHorizontalSpacing, important))
                 return false;
-            CSSValue value = m_parsedProperties.last().value();
+            const CSSValue& value = m_parsedProperties.last().value();
             addProperty(CSSPropertyWebkitBorderVerticalSpacing, value, important);
             return true;
         }
         else if (num == 2) {
             ShorthandScope scope(this, CSSPropertyBorderSpacing);
             if (!parseValue(CSSPropertyWebkitBorderHorizontalSpacing, important) || !parseValue(CSSPropertyWebkitBorderVerticalSpacing, important))
                 return false;
             return true;
         }
         return false;
@@ skipping 1021 matching lines @@
     ASSERT(!m_parsedCalculation);
     if (parsedValue) {
         if (!m_valueList->current() || inShorthand()) {
             addProperty(propId, *parsedValue, important);
             return true;
         }
     }
     return false;
 }
 
-void CSSPropertyParser::addFillValue(NullableCSSValue& lval, CSSValue rval)
+void CSSPropertyParser::addFillValue(NullableCSSValue& lval, const CSSValue& rval)
 {
     if (lval) {
         if (lval->isBaseValueList())
             toCSSValueList(lval)->append(rval);
         else {
             PassRefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
             list->append(*lval);
             list->append(rval);
             lval = list;
         }
@@ skipping 168 matching lines @@
 }
 
 static bool isValidTransitionPropertyList(CSSValueList* value)
 {
     if (value->length() < 2)
         return true;
     for (auto& property : *value) {
         // FIXME: Shorthand parsing shouldn't add initial to the list since it won't round-trip
         if (property.isInitialValue())
             continue;
-        CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(property);
+        const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(property);
         if (primitiveValue.isValueID() && primitiveValue.getValueID() == CSSValueNone)
             return false;
     }
     return true;
 }
 
 bool CSSPropertyParser::parseAnimationShorthand(bool useLegacyparsing, bool important)
 {
     const StylePropertyShorthand& animationProperties = animationShorthandForParsing();
     const unsigned numProperties = 8;
@@ skipping 245 matching lines @@
 
     int num = inShorthand() ? 1 : m_valueList->size();
 
     ShorthandScope scope(this, propId);
 
     // the order is top, right, bottom, left
     switch (num) {
         case 1: {
             if (!parseValue(properties[0], important))
                 return false;
-            CSSValue value = m_parsedProperties.last().value();
+            const CSSValue& value = m_parsedProperties.last().value();
             ImplicitScope implicitScope(this);
             addProperty(properties[1], value, important);
             addProperty(properties[2], value, important);
             addProperty(properties[3], value, important);
             break;
         }
         case 2: {
             if (!parseValue(properties[0], important) || !parseValue(properties[1], important))
                 return false;
-            CSSValue value = m_parsedProperties[m_parsedProperties.size() - 2].value();
+            const CSSValue& value = m_parsedProperties[m_parsedProperties.size() - 2].value();
             ImplicitScope implicitScope(this);
             addProperty(properties[2], value, important);
-            value = m_parsedProperties[m_parsedProperties.size() - 2].value();
             addProperty(properties[3], value, important);
             break;
         }
         case 3: {
             if (!parseValue(properties[0], important) || !parseValue(properties[1], important) || !parseValue(properties[2], important))
                 return false;
-            CSSValue value = m_parsedProperties[m_parsedProperties.size() - 2].value();
+            const CSSValue& value = m_parsedProperties[m_parsedProperties.size() - 2].value();
             ImplicitScope implicitScope(this);
             addProperty(properties[3], value, important);
             break;
         }
         case 4: {
             if (!parseValue(properties[0], important) || !parseValue(properties[1], important) ||
                 !parseValue(properties[2], important) || !parseValue(properties[3], important))
                 return false;
             break;
         }
@@ skipping 426 matching lines @@
         return true;
 
     return false;
 }
 
 static bool isFillPositionKeyword(CSSValueID value)
 {
     return value == CSSValueLeft || value == CSSValueTop || value == CSSValueBottom || value == CSSValueRight || value == CSSValueCenter;
 }
 
-void CSSPropertyParser::parse4ValuesFillPosition(CSSParserValueList* valueList, NullableCSSValue& value1, NullableCSSValue& value2, CSSPrimitiveValue parsedValue1, CSSPrimitiveValue parsedValue2)
+void CSSPropertyParser::parse4ValuesFillPosition(CSSParserValueList* valueList, NullableCSSValue& value1, NullableCSSValue& value2, const CSSPrimitiveValue& parsedValue1, const CSSPrimitiveValue& parsedValue2)
 {
     // [ left | right ] [ <percentage] | <length> ] && [ top | bottom ] [ <percentage> | <length> ]
     // In the case of 4 values <position> requires the second value to be a length or a percentage.
     if (isFillPositionKeyword(parsedValue2.getValueID()))
         return;
 
     unsigned cumulativeFlags = 0;
     FillPositionFlag value3Flag = InvalidFillPosition;
     NullableCSSValue value3 = parseFillPositionComponent(valueList, cumulativeFlags, value3Flag, ResolveValuesAsKeyword);
     if (!value3)
@@ skipping 27 matching lines @@
         return;
 
     value1 = createPrimitiveValuePair(parsedValue1, parsedValue2);
     value2 = createPrimitiveValuePair(toCSSPrimitiveValue(*value3), toCSSPrimitiveValue(*value4));
 
     if (ident1 == CSSValueTop || ident1 == CSSValueBottom)
         value1.swap(value2);
 
     valueList->next();
 }
-void CSSPropertyParser::parse3ValuesFillPosition(CSSParserValueList* valueList, NullableCSSValue& value1, NullableCSSValue& value2, CSSPrimitiveValue parsedValue1, CSSPrimitiveValue parsedValue2)
+void CSSPropertyParser::parse3ValuesFillPosition(CSSParserValueList* valueList, NullableCSSValue& value1, NullableCSSValue& value2, const CSSPrimitiveValue& parsedValue1, const CSSPrimitiveValue& parsedValue2)
 {
     unsigned cumulativeFlags = 0;
     FillPositionFlag value3Flag = InvalidFillPosition;
     NullableCSSValue value3 = parseFillPositionComponent(valueList, cumulativeFlags, value3Flag, ResolveValuesAsKeyword);
 
     // value3 is not an expected value, we return.
     if (!value3)
         return;
 
     valueList->next();
@@ skipping 61 matching lines @@
             return;
 
         value1 = createPrimitiveValuePair(parsedValue1, toCSSPrimitiveValue(*firstPositionValue));
         value2 = createPrimitiveValuePair(cssValuePool().createIdentifierValue(secondPositionKeyword), toCSSPrimitiveValue(*secondPositionValue));
     }
 
     if (ident1 == CSSValueTop || ident1 == CSSValueBottom || swapNeeded)
         value1.swap(value2);
 
 #if ENABLE(ASSERT)
-    CSSPrimitiveValue first = toCSSPrimitiveValue(*value1);
-    CSSPrimitiveValue second = toCSSPrimitiveValue(*value2);
-    ident1 = toCSSPrimitiveValue(*first.getPairValue()->first()).getValueID();
-    ident2 = toCSSPrimitiveValue(*second.getPairValue()->first()).getValueID();
+    const CSSPrimitiveValue& first = toCSSPrimitiveValue(*value1);
+    const CSSPrimitiveValue& second = toCSSPrimitiveValue(*value2);
+    ident1 = first.getPairValue()->first().getValueID();
+    ident2 = second.getPairValue()->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 37 matching lines @@
     // a valid start for <position>.
     cumulativeFlags = AmbiguousFillPosition;
     value2 = parseFillPositionComponent(valueList, cumulativeFlags, value2Flag, ResolveValuesAsKeyword);
     if (value2)
         valueList->next();
     else {
         value1 = nullptr;
         return;
     }
 
+    // Explicitly make copies.
     CSSPrimitiveValue parsedValue1 = toCSSPrimitiveValue(*value1);
     CSSPrimitiveValue parsedValue2 = toCSSPrimitiveValue(*value2);
 
     value1 = nullptr;
     value2 = nullptr;
 
     // Per CSS3 syntax, <position> can't have 'center' as its second keyword as we have more arguments to follow.
     if (parsedValue2.getValueID() == CSSValueCenter)
         return;
 
@@ skipping 2524 matching lines @@
 
         allowX = true;
         allowColor = true;
         allowBreak = true;
         allowY = false;
         allowBlur = false;
         allowSpread = false;
         allowStyle = property == CSSPropertyBoxShadow;
     }
 
-    void commitLength(CSSPrimitiveValue val)
+    void commitLength(const CSSPrimitiveValue& val)
     {
         if (allowX) {
             x = val;
             allowX = false;
             allowY = true;
             allowColor = false;
             allowStyle = false;
             allowBreak = false;
         } else if (allowY) {
             y = val;
             allowY = false;
             allowBlur = true;
             allowColor = true;
             allowStyle = property == CSSPropertyBoxShadow;
             allowBreak = true;
         } else if (allowBlur) {
             blur = val;
             allowBlur = false;
             allowSpread = property == CSSPropertyBoxShadow;
         } else if (allowSpread) {
             spread = val;
             allowSpread = false;
         }
     }
 
-    void commitColor(CSSPrimitiveValue val)
+    void commitColor(const CSSPrimitiveValue& val)
     {
         color = val;
         allowColor = false;
         if (allowX) {
             allowStyle = false;
             allowBreak = false;
         } else {
             allowBlur = false;
             allowSpread = false;
             allowStyle = property == CSSPropertyBoxShadow;
@@ skipping 266 matching lines @@
         if (!m_borderWidth && !m_allowWidth) {
             m_allowForwardSlashOperator = true;
             m_allowWidth = true;
             m_requireOutset = false;
         } else {
             m_allowForwardSlashOperator = false;
             m_requireOutset = true;
             m_allowWidth = false;
         }
     }
-    void commitBorderWidth(CSSPrimitiveValue width)
+    void commitBorderWidth(const CSSPrimitiveValue& width)
     {
         m_borderWidth = width;
         m_canAdvance = true;
         m_allowCommit = true;
         m_allowForwardSlashOperator = true;
         m_allowImageSlice = false;
         m_allowWidth = false;
         m_requireOutset = false;
         m_allowImage = !m_image;
         m_allowRepeat = !m_repeat;
     }
-    void commitBorderOutset(CSSPrimitiveValue outset)
+    void commitBorderOutset(const CSSPrimitiveValue& outset)
     {
         m_outset = outset;
         m_canAdvance = true;
         m_allowCommit = true;
         m_allowImageSlice = false;
         m_allowForwardSlashOperator = false;
         m_allowWidth = false;
         m_requireOutset = false;
         m_allowImage = !m_image;
         m_allowRepeat = !m_repeat;
@@ skipping 89 matching lines @@
 
         if (!context.canAdvance())
             return false;
 
         m_valueList->next();
     }
 
     return context.allowCommit();
 }
 
-void CSSPropertyParser::commitBorderImageProperty(CSSPropertyID propId, NullableCSSValue value, bool important)
+void CSSPropertyParser::commitBorderImageProperty(CSSPropertyID propId, const NullableCSSValue& value, bool important)
 {
     if (value)
         addProperty(propId, *value, important);
     else
         addProperty(propId, cssValuePool().createImplicitInitialValue(), important, true);
 }
 
 bool CSSPropertyParser::parseBorderImageShorthand(CSSPropertyID propId, bool important)
 {
     BorderImageParseContext context;
@@ skipping 73 matching lines @@
     BorderImageSliceParseContext()
     : m_allowNumber(true)
     , m_allowFill(true)
     , m_allowFinalCommit(false)
     , m_fill(false)
     { }
 
     bool allowNumber() const { return m_allowNumber; }
     bool allowFill() const { return m_allowFill; }
     bool allowFinalCommit() const { return m_allowFinalCommit; }
-    NullableCSSValue top() const { return m_top; }
+    const NullableCSSValue& top() const { return m_top; }
 
-    void commitNumber(CSSPrimitiveValue val)
+    void commitNumber(const CSSPrimitiveValue& val)
     {
         if (!m_top)
             m_top = val;
         else if (!m_right)
             m_right = val;
         else if (!m_bottom)
             m_bottom = val;
         else {
             ASSERT(!m_left);
             m_left = val;
@@ skipping 83 matching lines @@
 class BorderImageQuadParseContext {
     STACK_ALLOCATED();
 public:
     BorderImageQuadParseContext()
     : m_allowNumber(true)
     , m_allowFinalCommit(false)
     { }
 
     bool allowNumber() const { return m_allowNumber; }
     bool allowFinalCommit() const { return m_allowFinalCommit; }
-    NullableCSSValue top() const { return m_top; }
+    const NullableCSSValue& top() const { return m_top; }
 
-    void commitNumber(CSSPrimitiveValue val)
+    void commitNumber(const CSSPrimitiveValue& val)
     {
         if (!m_top)
             m_top = val;
         else if (!m_right)
             m_right = val;
         else if (!m_bottom)
             m_bottom = val;
         else {
             ASSERT(!m_left);
             m_left = val;
         }
 
         m_allowNumber = !m_left;
         m_allowFinalCommit = true;
     }
 
-    void setTop(CSSPrimitiveValue val) { m_top = val; }
+    void setTop(const CSSPrimitiveValue& val) { m_top = val; }
 
-    CSSPrimitiveValue commitBorderImageQuad()
+    const CSSPrimitiveValue commitBorderImageQuad()
     {
         // We need to clone and repeat values for any omissions.
         ASSERT(m_top);
         if (!m_right) {
             m_right = m_top;
             m_bottom = m_top;
             m_left = m_top;
         }
         if (!m_bottom) {
             m_bottom = m_top;
@@ skipping 2375 matching lines @@
         }
     }
 
     if (!list->length())
         return nullptr;
 
     return list.release();
 }
 
 } // namespace blink