Reduce usage of CSSParserValueList::size

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 446 matching lines @@
             return false;
         addExpandedPropertyForValue(propId, cssValuePool().createExplicitInitialValue(), important);
         return true;
     } else if (id == CSSValueUnset) {
         if (m_valueList->size() != 1)
             return false;
         addExpandedPropertyForValue(propId, cssValuePool().createUnsetValue(), important);
         return true;
     }
 
-    int num = inShorthand() ? 1 : m_valueList->size();
-
     if (CSSParserFastPaths::isKeywordPropertyID(propId)) {
         if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(propId, id))
             return false;
         if (m_valueList->next() && !inShorthand())
             return false;
         addProperty(propId, cssValuePool().createIdentifierValue(id), important);
         return true;
     }
 
     bool validPrimitive = false;
@@ skipping 20 matching lines @@
             validPrimitive = true;
         else if (value->m_unit == CSSParserValue::Function)
             parsedValue = parseClipShape();
         break;
 
     /* Start of supported CSS properties with validation. This is needed for parseShorthand to work
      * correctly and allows optimization in blink::applyRule(..)
      */
     case CSSPropertyOverflow: {
         ShorthandScope scope(this, propId);
-        if (num != 1 || !parseValue(CSSPropertyOverflowY, important))
+        if (!parseValue(CSSPropertyOverflowY, important) || m_valueList->current())
             return false;
 
         RefPtrWillBeRawPtr<CSSValue> overflowXValue = nullptr;
 
         // FIXME: -webkit-paged-x or -webkit-paged-y only apply to overflow-y. If this value has been
         // set using the shorthand, then for now overflow-x will default to auto, but once we implement
         // pagination controls, it should default to hidden. If the overflow-y value is anything but
         // paged-x or paged-y, then overflow-x and overflow-y should have the same value.
         if (id == CSSValueWebkitPagedX || id == CSSValueWebkitPagedY)
             overflowXValue = cssValuePool().createIdentifierValue(CSSValueAuto);
         else
             overflowXValue = m_parsedProperties.last().value();
         addProperty(CSSPropertyOverflowX, overflowXValue.release(), important);
         return true;
     }
 
     case CSSPropertyTextAlign:
         // left | right | center | justify | -webkit-left | -webkit-right | -webkit-center | -webkit-match-parent
         // | start | end | <string> | inherit | -webkit-auto (converted to start)
         // FIXME: <string> not supported right now
         if ((id >= CSSValueWebkitAuto && id <= CSSValueWebkitMatchParent) || id == CSSValueStart || id == CSSValueEnd) {
             validPrimitive = true;
         }
         break;
 
-    case CSSPropertyFontWeight:  { // normal | bold | bolder | lighter | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | inherit
-        if (m_valueList->size() != 1)
-            return false;
-        return parseFontWeight(important);
-    }
+    case CSSPropertyFontWeight: // normal | bold | bolder | lighter | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | inherit
+        return parseFontWeight(important) && !m_valueList->next();
 
     case CSSPropertyBorderSpacing: {
-        if (num == 1) {
-            ShorthandScope scope(this, CSSPropertyBorderSpacing);
-            if (!parseValue(CSSPropertyWebkitBorderHorizontalSpacing, important))
-                return false;
+        ShorthandScope scope(this, CSSPropertyBorderSpacing);
+        if (!parseValue(CSSPropertyWebkitBorderHorizontalSpacing, important))
+            return false;
+        if (!m_valueList->current()) {
             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;
+        if (!parseValue(CSSPropertyWebkitBorderVerticalSpacing, important))
+            return false;
+        return !m_valueList->current();
     }
     case CSSPropertyWebkitBorderHorizontalSpacing:
     case CSSPropertyWebkitBorderVerticalSpacing:
         unitless = FLength | FNonNeg;
         if (inShorthand() && m_currentShorthand == CSSPropertyBorderSpacing)
             unitless = unitless | FUnitlessQuirk;
         validPrimitive = validUnit(value, unitless);
         break;
     case CSSPropertyOutlineColor:        // <color> | invert | inherit
         // Outline color has "invert" as additional keyword.
@@ skipping 404 matching lines @@
         if (parseBorderImageWidth(result)) {
             addProperty(propId, result, important);
             return true;
         }
         break;
     }
     case CSSPropertyBorderTopRightRadius:
     case CSSPropertyBorderTopLeftRadius:
     case CSSPropertyBorderBottomLeftRadius:
     case CSSPropertyBorderBottomRightRadius: {
-        if (num != 1 && num != 2)
-            return false;
         validPrimitive = validUnit(value, FLength | FPercent | FNonNeg);
         if (!validPrimitive)
             return false;
         RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue1 = createPrimitiveNumericValue(value);
         RefPtrWillBeRawPtr<CSSPrimitiveValue> parsedValue2 = nullptr;
-        if (num == 2) {
-            value = m_valueList->next();
+        value = m_valueList->next();
+        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);
         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);
@@ skipping 287 matching lines @@
 
     case CSSPropertyGridTemplate:
         ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
         return parseGridTemplateShorthand(important);
 
     case CSSPropertyGrid:
         ASSERT(RuntimeEnabledFeatures::cssGridLayoutEnabled());
         return parseGridShorthand(important);
 
     case CSSPropertyWebkitMarginCollapse: {
-        if (num == 1) {
-            ShorthandScope scope(this, CSSPropertyWebkitMarginCollapse);
-            if (!parseValue(webkitMarginCollapseShorthand().properties()[0], important))
-                return false;
+        ShorthandScope scope(this, CSSPropertyWebkitMarginCollapse);
+        if (!parseValue(webkitMarginCollapseShorthand().properties()[0], important))
+            return false;
+        if (!m_valueList->current()) {
             CSSValue* value = m_parsedProperties.last().value();
             addProperty(webkitMarginCollapseShorthand().properties()[1], value, important);
             return true;
         }
-        else if (num == 2) {
-            ShorthandScope scope(this, CSSPropertyWebkitMarginCollapse);
-            if (!parseValue(webkitMarginCollapseShorthand().properties()[0], important) || !parseValue(webkitMarginCollapseShorthand().properties()[1], important))
-                return false;
-            return true;
-        }
-        return false;
+        if (!parseValue(webkitMarginCollapseShorthand().properties()[1], important))
+            return false;
+        return !m_valueList->current();
     }
     case CSSPropertyWebkitColumnCount:
         parsedValue = parseColumnCount();
         break;
     case CSSPropertyWebkitColumnGap:         // normal | <length>
         if (id == CSSValueNormal)
             validPrimitive = true;
         else
             validPrimitive = validUnit(value, FLength | FNonNeg);
         break;
@@ skipping 113 matching lines @@
         // <margin-width>{1,4} | inherit
         return parse4Values(propId, marginShorthand().properties(), important);
     case CSSPropertyPadding:
         // <padding-width>{1,4} | inherit
         return parse4Values(propId, paddingShorthand().properties(), important);
     case CSSPropertyFlexFlow:
         return parseShorthand(propId, flexFlowShorthand(), important);
     case CSSPropertyFont:
         // [ [ 'font-style' || 'font-variant' || 'font-weight' ]? 'font-size' [ / 'line-height' ]?
         // 'font-family' ] | caption | icon | menu | message-box | small-caption | status-bar | inherit
-        if (num == 1 && id >= CSSValueCaption && id <= CSSValueStatusBar) {
-            parseSystemFont(important);
-            return true;
-        }
+        if (id >= CSSValueCaption && id <= CSSValueStatusBar)
+            return parseSystemFont(important);
         return parseFont(important);
     case CSSPropertyListStyle:
         return parseShorthand(propId, listStyleShorthand(), important);
     case CSSPropertyWebkitColumns:
         return parseColumnsShorthand(important);
     case CSSPropertyWebkitColumnRule:
         return parseShorthand(propId, webkitColumnRuleShorthand(), important);
     case CSSPropertyWebkitTextStroke:
         return parseShorthand(propId, webkitTextStrokeShorthand(), important);
     case CSSPropertyAnimation:
@@ skipping 3177 matching lines @@
 
     // FIXME: http://www.w3.org/TR/2011/WD-css3-fonts-20110324/#font-prop requires that
     // "font-stretch", "font-size-adjust", and "font-kerning" be reset to their initial values
     // but we don't seem to support them at the moment. They should also be added here once implemented.
     if (m_valueList->current())
         return false;
 
     return true;
 }
 
-void CSSPropertyParser::parseSystemFont(bool important)
+bool CSSPropertyParser::parseSystemFont(bool important)
 {
-    ASSERT(m_valueList->size() == 1);
     CSSValueID systemFontID = m_valueList->valueAt(0)->id;
     ASSERT(systemFontID >= CSSValueCaption && systemFontID <= CSSValueStatusBar);
-    m_valueList->next();
+    if (m_valueList->next())
+        return false;
 
     FontStyle fontStyle = FontStyleNormal;
     FontWeight fontWeight = FontWeightNormal;
     float fontSize = 0;
     AtomicString fontFamily;
     LayoutTheme::theme().systemFont(systemFontID, fontStyle, fontWeight, fontSize, fontFamily);
 
     ShorthandScope scope(this, CSSPropertyFont);
     addProperty(CSSPropertyFontStyle, cssValuePool().createIdentifierValue(fontStyle == FontStyleItalic ? CSSValueItalic : CSSValueNormal), important);
     addProperty(CSSPropertyFontWeight, cssValuePool().createValue(fontWeight), important);
     addProperty(CSSPropertyFontSize, cssValuePool().createValue(fontSize, CSSPrimitiveValue::UnitType::Pixels), important);
     RefPtrWillBeRawPtr<CSSValueList> fontFamilyList = CSSValueList::createCommaSeparated();
     fontFamilyList->append(cssValuePool().createFontFamilyValue(fontFamily));
     addProperty(CSSPropertyFontFamily, fontFamilyList.release(), important);
 
     addProperty(CSSPropertyFontStretch, cssValuePool().createIdentifierValue(CSSValueNormal), important);
     addProperty(CSSPropertyFontVariant, cssValuePool().createIdentifierValue(CSSValueNormal), important);
     addProperty(CSSPropertyLineHeight, cssValuePool().createIdentifierValue(CSSValueNormal), important);
+    return true;
 }
 
 class FontFamilyValueBuilder {
     STACK_ALLOCATED();
 public:
     FontFamilyValueBuilder(CSSValueList* list)
         : m_list(list)
     {
     }
 
@@ skipping 2746 matching lines @@
         // TODO(rwlbuis): check there is only one family-name
         parsedValue = parseFontFamily();
         break;
     case CSSPropertySrc: // This is a list of urls or local references.
         parsedValue = parseFontFaceSrc();
         break;
     case CSSPropertyUnicodeRange:
         parsedValue = parseFontFaceUnicodeRange();
         break;
     case CSSPropertyFontWeight: // normal | bold | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900
-        if (m_valueList->size() != 1)
-            return false;
-        return parseFontWeight(false);
+        return parseFontWeight(false) && !m_valueList->next();
     case CSSPropertyFontStretch:
     case CSSPropertyFontStyle:
         if (!CSSParserFastPaths::isValidKeywordPropertyAndValue(propId, id))
             return false;
         addProperty(propId, cssValuePool().createIdentifierValue(id), false);
         return true;
     case CSSPropertyFontVariant: // normal | small-caps | inherit
         return parseFontVariant(false);
     case CSSPropertyWebkitFontFeatureSettings:
         if (id == CSSValueNormal) {
@@ skipping 667 matching lines @@
         }
     }
 
     if (!list->length())
         return nullptr;
 
     return list.release();
 }
 
 } // namespace blink