Remove css !important

sky/engine/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 96 matching lines @@
     , m_context(context)
     , m_inViewport(inViewport)
     , m_parsedProperties(parsedProperties)
     , m_ruleType(ruleType)
     , m_inParseShorthand(0)
     , m_currentShorthand(CSSPropertyInvalid)
     , m_implicitShorthand(false)
 {
 }
 
-bool CSSPropertyParser::parseValue(CSSPropertyID property, bool important,
+bool CSSPropertyParser::parseValue(CSSPropertyID property,
     CSSParserValueList* valueList, const CSSParserContext& context, bool inViewport,
     Vector<CSSProperty, 256>& parsedProperties, CSSRuleSourceData::Type ruleType)
 {
     CSSPropertyParser parser(valueList, context, inViewport, parsedProperties, ruleType);
-    return parser.parseValue(property, important);
+    return parser.parseValue(property);
 }
 
-void CSSPropertyParser::addProperty(CSSPropertyID propId, PassRefPtr<CSSValue> value, bool important, bool implicit)
+void CSSPropertyParser::addProperty(CSSPropertyID propId, PassRefPtr<CSSValue> value, bool implicit)
 {
     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
         // make sense for CSSProperties.in to consider them as such. The shorthand
         // index is only used by the inspector and doesn't affect viewport
         // descriptors.
         if (shorthands.isEmpty())
             ASSERT(m_currentShorthand == CSSPropertyWidth || m_currentShorthand == CSSPropertyHeight);
         else
             setFromShorthand = true;
 
         if (shorthands.size() > 1)
             shorthandIndex = indexOfShorthandForLonghand(m_currentShorthand, shorthands);
     }
 
-    m_parsedProperties.append(CSSProperty(propId, value, important, setFromShorthand, shorthandIndex, m_implicitShorthand || implicit));
+    m_parsedProperties.append(CSSProperty(propId, value, setFromShorthand, shorthandIndex, m_implicitShorthand || implicit));
 }
 
 void CSSPropertyParser::rollbackLastProperties(int num)
 {
     ASSERT(num >= 0);
     ASSERT(m_parsedProperties.size() >= static_cast<unsigned>(num));
     m_parsedProperties.shrink(m_parsedProperties.size() - num);
 }
 
 KURL CSSPropertyParser::completeURL(const String& url) const
@@ skipping 216 matching lines @@
     if (value->unit >= CSSPrimitiveValue::CSS_VW && value->unit <= CSSPrimitiveValue::CSS_VMAX)
         return createPrimitiveNumericValue(value);
     if (value->unit >= CSSPrimitiveValue::CSS_DPPX && value->unit <= CSSPrimitiveValue::CSS_DPCM)
         return createPrimitiveNumericValue(value);
     if (isCalculation(value))
         return CSSPrimitiveValue::create(m_parsedCalculation.release());
 
     return nullptr;
 }
 
-void CSSPropertyParser::addExpandedPropertyForValue(CSSPropertyID propId, PassRefPtr<CSSValue> prpValue, bool important)
+void CSSPropertyParser::addExpandedPropertyForValue(CSSPropertyID propId, PassRefPtr<CSSValue> prpValue)
 {
     const StylePropertyShorthand& shorthand = shorthandForProperty(propId);
     unsigned shorthandLength = shorthand.length();
     if (!shorthandLength) {
-        addProperty(propId, prpValue, important);
+        addProperty(propId, prpValue);
         return;
     }
 
     RefPtr<CSSValue> value = prpValue;
     ShorthandScope scope(this, propId);
     const CSSPropertyID* longhands = shorthand.properties();
     for (unsigned i = 0; i < shorthandLength; ++i)
-        addProperty(longhands[i], value, important);
+        addProperty(longhands[i], value);
 }
 
-bool CSSPropertyParser::parseValue(CSSPropertyID propId, bool important)
+bool CSSPropertyParser::parseValue(CSSPropertyID propId)
 {
     if (!isInternalPropertyAndValueParsingEnabledForMode(m_context.mode()) && isInternalProperty(propId))
         return false;
 
     // We don't count the UA style sheet in our statistics.
     if (m_context.useCounter())
         m_context.useCounter()->count(m_context, propId);
 
     if (!m_valueList)
         return false;
 
     CSSParserValue* value = m_valueList->current();
 
     if (!value)
         return false;
 
     if (inViewport()) {
         // Allow @viewport rules from UA stylesheets even if the feature is disabled.
         if (!RuntimeEnabledFeatures::cssViewportEnabled() && !isUASheetBehavior(m_context.mode()))
             return false;
 
-        return parseViewportProperty(propId, important);
+        return parseViewportProperty(propId);
     }
 
     // Note: m_parsedCalculation is used to pass the calc value to validUnit and then cleared at the end of this function.
     // FIXME: This is to avoid having to pass parsedCalc to all validUnit callers.
     ASSERT(!m_parsedCalculation);
 
     CSSValueID id = value->id;
 
     int num = inShorthand() ? 1 : m_valueList->size();
 
     if (id == CSSValueInherit) {
         if (num != 1)
             return false;
-        addExpandedPropertyForValue(propId, cssValuePool().createInheritedValue(), important);
+        addExpandedPropertyForValue(propId, cssValuePool().createInheritedValue());
         return true;
     }
     else if (id == CSSValueInitial) {
         if (num != 1)
             return false;
-        addExpandedPropertyForValue(propId, cssValuePool().createExplicitInitialValue(), important);
+        addExpandedPropertyForValue(propId, cssValuePool().createExplicitInitialValue());
         return true;
     }
 
     if (isKeywordPropertyID(propId)) {
         if (!isValidKeywordPropertyAndValue(propId, id, m_context))
             return false;
         if (m_valueList->next() && !inShorthand())
             return false;
-        addProperty(propId, cssValuePool().createIdentifierValue(id), important);
+        addProperty(propId, cssValuePool().createIdentifierValue(id));
         return true;
     }
 
     bool validPrimitive = false;
     RefPtr<CSSValue> parsedValue = nullptr;
 
     switch (propId) {
     case CSSPropertySize:                 // <length>{1,2} | auto | [ <page-size> || [ portrait | landscape] ]
-        return parseSize(propId, important);
+        return parseSize(propId);
 
     case CSSPropertyQuotes: // [<string> <string>]+ | none
         if (id == CSSValueNone)
             validPrimitive = true;
         else
             parsedValue = parseQuotes();
         break;
 
     case CSSPropertyClip:                 // <shape> | auto | inherit
         if (id == CSSValueAuto)
             validPrimitive = true;
         else if (value->unit == CSSParserValue::Function)
-            return parseClipShape(propId, important);
+            return parseClipShape(propId);
         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 (num != 1 || !parseValue(CSSPropertyOverflowY))
             return false;
 
         RefPtr<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);
+        addProperty(CSSPropertyOverflowX, overflowXValue.release());
         return true;
     }
 
     case CSSPropertyTextAlign:
         // left | right | center | justify | -webkit-match-parent
         // | start | end | <string> | inherit
         if ((id >= CSSValueLeft && id <= CSSValueWebkitMatchParent) || id == CSSValueStart || id == CSSValueEnd
             || value->unit == CSSPrimitiveValue::CSS_STRING)
             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);
+        return parseFontWeight();
     }
 
     case CSSPropertyBorderSpacing: {
         if (num == 1) {
             ShorthandScope scope(this, CSSPropertyBorderSpacing);
-            if (!parseValue(CSSPropertyWebkitBorderHorizontalSpacing, important))
+            if (!parseValue(CSSPropertyWebkitBorderHorizontalSpacing))
                 return false;
             CSSValue* value = m_parsedProperties.last().value();
-            addProperty(CSSPropertyWebkitBorderVerticalSpacing, value, important);
+            addProperty(CSSPropertyWebkitBorderVerticalSpacing, value);
             return true;
         }
         else if (num == 2) {
             ShorthandScope scope(this, CSSPropertyBorderSpacing);
-            if (!parseValue(CSSPropertyWebkitBorderHorizontalSpacing, important) || !parseValue(CSSPropertyWebkitBorderVerticalSpacing, important))
+            if (!parseValue(CSSPropertyWebkitBorderHorizontalSpacing) || !parseValue(CSSPropertyWebkitBorderVerticalSpacing))
                 return false;
             return true;
         }
         return false;
     }
     case CSSPropertyWebkitBorderHorizontalSpacing:
     case CSSPropertyWebkitBorderVerticalSpacing:
         validPrimitive = validUnit(value, FLength | FNonNeg);
         break;
     case CSSPropertyOutlineColor:        // <color> | invert | inherit
@@ skipping 129 matching lines @@
         RefPtr<CSSValue> val1 = nullptr;
         RefPtr<CSSValue> val2 = nullptr;
         CSSPropertyID propId1, propId2;
         bool result = false;
         if (parseFillProperty(propId, propId1, propId2, val1, val2)) {
             if (propId == CSSPropertyBackgroundPosition ||
                 propId == CSSPropertyBackgroundRepeat ||
                 propId == CSSPropertyWebkitMaskPosition ||
                 propId == CSSPropertyWebkitMaskRepeat) {
                 ShorthandScope scope(this, propId);
-                addProperty(propId1, val1.release(), important);
+                addProperty(propId1, val1.release());
                 if (val2)
-                    addProperty(propId2, val2.release(), important);
+                    addProperty(propId2, val2.release());
             } else {
-                addProperty(propId1, val1.release(), important);
+                addProperty(propId1, val1.release());
                 if (val2)
-                    addProperty(propId2, val2.release(), important);
+                    addProperty(propId2, val2.release());
             }
             result = true;
         }
         m_implicitShorthand = false;
         return result;
     }
     case CSSPropertyObjectPosition:
         ASSERT(RuntimeEnabledFeatures::objectFitPositionEnabled());
         parsedValue = parseObjectPosition();
         break;
@@ skipping 74 matching lines @@
         break;
 
     case CSSPropertyWidth:
     case CSSPropertyWebkitLogicalWidth:
     case CSSPropertyHeight:
     case CSSPropertyWebkitLogicalHeight:
         validPrimitive = (id == CSSValueAuto || validWidthOrHeight(value));
         break;
 
     case CSSPropertyFontSize:
-        return parseFontSize(important);
+        return parseFontSize();
 
     case CSSPropertyFontVariant:         // normal | small-caps | inherit
-        return parseFontVariant(important);
+        return parseFontVariant();
 
     case CSSPropertyVerticalAlign:
         // baseline | sub | super | top | text-top | middle | bottom | text-bottom |
         // <percentage> | <length> | inherit
 
         if (id >= CSSValueBaseline && id <= CSSValueWebkitBaselineMiddle)
             validPrimitive = true;
         else
             validPrimitive = (!id && validUnit(value, FLength | FPercent));
         break;
@@ skipping 25 matching lines @@
         break;
 
     case CSSPropertyZIndex: // auto | <integer> | inherit
         if (id == CSSValueAuto)
             validPrimitive = true;
         else
             validPrimitive = (!id && validUnit(value, FInteger));
         break;
 
     case CSSPropertyLineHeight:
-        return parseLineHeight(important);
+        return parseLineHeight();
     case CSSPropertyFontFamily:
         // [[ <family-name> | <generic-family> ],]* [<family-name> | <generic-family>] | inherit
     {
         parsedValue = parseFontFamily();
         break;
     }
 
     case CSSPropertyTextDecoration:
         // Fall through 'text-decoration-line' parsing if CSS 3 Text Decoration
         // is disabled to match CSS 2.1 rules for parsing 'text-decoration'.
         if (RuntimeEnabledFeatures::css3TextDecorationsEnabled()) {
             // [ <text-decoration-line> || <text-decoration-style> || <text-decoration-color> ] | inherit
-            return parseShorthand(CSSPropertyTextDecoration, textDecorationShorthand(), important);
+            return parseShorthand(CSSPropertyTextDecoration, textDecorationShorthand());
         }
     case CSSPropertyWebkitTextDecorationsInEffect:
     case CSSPropertyTextDecorationLine:
         // none | [ underline || overline || line-through || blink ] | inherit
-        return parseTextDecoration(propId, important);
+        return parseTextDecoration(propId);
 
     case CSSPropertyTextUnderlinePosition:
         // auto | under | inherit
         ASSERT(RuntimeEnabledFeatures::css3TextDecorationsEnabled());
-        return parseTextUnderlinePosition(important);
+        return parseTextUnderlinePosition();
 
-    case CSSPropertySrc: // Only used within @font-face and @-webkit-filter, so cannot use inherit | initial or be !important. This is a list of urls or local references.
+    case CSSPropertySrc: // Only used within @font-face and @-webkit-filter, so cannot use inherit | initial. This is a list of urls or local references.
         parsedValue = parseFontFaceSrc();
         break;
 
     case CSSPropertyUnicodeRange:
         parsedValue = parseFontFaceUnicodeRange();
         break;
 
     /* CSS3 properties */
 
     case CSSPropertyBorderImage:
     case CSSPropertyWebkitMaskBoxImage:
-        return parseBorderImageShorthand(propId, important);
+        return parseBorderImageShorthand(propId);
     case CSSPropertyWebkitBorderImage: {
         if (RefPtr<CSSValue> result = parseBorderImage(propId)) {
-            addProperty(propId, result, important);
+            addProperty(propId, result);
             return true;
         }
         return false;
     }
 
     case CSSPropertyBorderImageOutset:
     case CSSPropertyWebkitMaskBoxImageOutset: {
         RefPtr<CSSPrimitiveValue> result = nullptr;
         if (parseBorderImageOutset(result)) {
-            addProperty(propId, result, important);
+            addProperty(propId, result);
             return true;
         }
         break;
     }
     case CSSPropertyBorderImageRepeat:
     case CSSPropertyWebkitMaskBoxImageRepeat: {
         RefPtr<CSSValue> result = nullptr;
         if (parseBorderImageRepeat(result)) {
-            addProperty(propId, result, important);
+            addProperty(propId, result);
             return true;
         }
         break;
     }
     case CSSPropertyBorderImageSlice:
     case CSSPropertyWebkitMaskBoxImageSlice: {
         RefPtr<CSSBorderImageSliceValue> result = nullptr;
         if (parseBorderImageSlice(propId, result)) {
-            addProperty(propId, result, important);
+            addProperty(propId, result);
             return true;
         }
         break;
     }
     case CSSPropertyBorderImageWidth:
     case CSSPropertyWebkitMaskBoxImageWidth: {
         RefPtr<CSSPrimitiveValue> result = nullptr;
         if (parseBorderImageWidth(result)) {
-            addProperty(propId, result, important);
+            addProperty(propId, result);
             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;
         RefPtr<CSSPrimitiveValue> parsedValue1 = createPrimitiveNumericValue(value);
         RefPtr<CSSPrimitiveValue> parsedValue2 = nullptr;
         if (num == 2) {
             value = m_valueList->next();
             validPrimitive = validUnit(value, FLength | FPercent | FNonNeg);
             if (!validPrimitive)
                 return false;
             parsedValue2 = createPrimitiveNumericValue(value);
         } else
             parsedValue2 = parsedValue1;
 
-        addProperty(propId, createPrimitiveValuePair(parsedValue1.release(), parsedValue2.release()), important);
+        addProperty(propId, createPrimitiveValuePair(parsedValue1.release(), parsedValue2.release()));
         return true;
     }
     case CSSPropertyTabSize:
         validPrimitive = validUnit(value, FInteger | FNonNeg);
         break;
     case CSSPropertyWebkitAspectRatio:
         parsedValue = parseAspectRatio();
         break;
     case CSSPropertyBorderRadius:
     case CSSPropertyWebkitBorderRadius:
-        return parseBorderRadius(propId, important);
+        return parseBorderRadius(propId);
     case CSSPropertyOutlineOffset:
         validPrimitive = validUnit(value, FLength);
         break;
     case CSSPropertyTextShadow: // CSS2 property, dropped in CSS2.1, back in CSS3, so treat as CSS3
     case CSSPropertyBoxShadow:
     case CSSPropertyWebkitBoxShadow:
         if (id == CSSValueNone)
             validPrimitive = true;
         else {
             RefPtr<CSSValueList> shadowValueList = parseShadow(m_valueList, propId);
             if (shadowValueList) {
-                addProperty(propId, shadowValueList.release(), important);
+                addProperty(propId, shadowValueList.release());
                 m_valueList->next();
                 return true;
             }
             return false;
         }
         break;
     case CSSPropertyOpacity:
         validPrimitive = validUnit(value, FNumber);
         break;
     case CSSPropertyFilter:
         if (id == CSSValueNone)
             validPrimitive = true;
         else {
             RefPtr<CSSValue> val = parseFilter();
             if (val) {
-                addProperty(propId, val, important);
+                addProperty(propId, val);
                 return true;
             }
             return false;
         }
         break;
     case CSSPropertyFlex: {
         ShorthandScope scope(this, propId);
         if (id == CSSValueNone) {
-            addProperty(CSSPropertyFlexGrow, cssValuePool().createValue(0, CSSPrimitiveValue::CSS_NUMBER), important);
-            addProperty(CSSPropertyFlexShrink, cssValuePool().createValue(0, CSSPrimitiveValue::CSS_NUMBER), important);
-            addProperty(CSSPropertyFlexBasis, cssValuePool().createIdentifierValue(CSSValueAuto), important);
+            addProperty(CSSPropertyFlexGrow, cssValuePool().createValue(0, CSSPrimitiveValue::CSS_NUMBER));
+            addProperty(CSSPropertyFlexShrink, cssValuePool().createValue(0, CSSPrimitiveValue::CSS_NUMBER));
+            addProperty(CSSPropertyFlexBasis, cssValuePool().createIdentifierValue(CSSValueAuto));
             return true;
         }
-        return parseFlex(m_valueList, important);
+        return parseFlex(m_valueList);
     }
     case CSSPropertyFlexBasis:
         // FIXME: Support intrinsic dimensions too.
         if (id == CSSValueAuto)
             validPrimitive = true;
         else
             validPrimitive = (!id && validUnit(value, FLength | FPercent | FNonNeg));
         break;
     case CSSPropertyFlexGrow:
     case CSSPropertyFlexShrink:
         validPrimitive = validUnit(value, FNumber | FNonNeg);
         break;
     case CSSPropertyOrder:
         validPrimitive = validUnit(value, FInteger);
         break;
     case CSSPropertyTransform:
     case CSSPropertyWebkitTransform:
         if (id == CSSValueNone)
             validPrimitive = true;
         else {
             RefPtr<CSSValue> transformValue = parseTransform(propId);
             if (transformValue) {
-                addProperty(propId, transformValue.release(), important);
+                addProperty(propId, transformValue.release());
                 return true;
             }
             return false;
         }
         break;
     case CSSPropertyTransformOrigin: {
         RefPtr<CSSValueList> list = parseTransformOrigin();
         if (!list)
             return false;
         // These values are added to match gecko serialization.
         if (list->length() == 1)
             list->append(cssValuePool().createValue(50, CSSPrimitiveValue::CSS_PERCENTAGE));
         if (list->length() == 2)
             list->append(cssValuePool().createValue(0, CSSPrimitiveValue::CSS_PX));
-        addProperty(propId, list.release(), important);
+        addProperty(propId, list.release());
         return true;
     }
     case CSSPropertyWebkitPerspectiveOriginX:
     case CSSPropertyWebkitTransformOriginX:
         parsedValue = parseFillPositionX(m_valueList);
         if (parsedValue)
             m_valueList->next();
         break;
     case CSSPropertyWebkitPerspectiveOriginY:
     case CSSPropertyWebkitTransformOriginY:
         parsedValue = parseFillPositionY(m_valueList);
         if (parsedValue)
             m_valueList->next();
         break;
     case CSSPropertyWebkitTransformOriginZ:
         validPrimitive = validUnit(value, FLength);
         break;
     case CSSPropertyWebkitTransformOrigin:
-        return parseWebkitTransformOriginShorthand(important);
+        return parseWebkitTransformOriginShorthand();
     case CSSPropertyPerspective:
         if (id == CSSValueNone) {
             validPrimitive = true;
         } else if (validUnit(value, FLength | FNonNeg)) {
-            addProperty(propId, createPrimitiveNumericValue(value), important);
+            addProperty(propId, createPrimitiveNumericValue(value));
             return true;
         }
         break;
     case CSSPropertyWebkitPerspective:
         if (id == CSSValueNone) {
             validPrimitive = true;
         } else if (validUnit(value, FNumber | FLength | FNonNeg)) {
             // Accepting valueless numbers is a quirk of the -webkit prefixed version of the property.
-            addProperty(propId, createPrimitiveNumericValue(value), important);
+            addProperty(propId, createPrimitiveNumericValue(value));
             return true;
         }
         break;
     case CSSPropertyPerspectiveOrigin: {
         RefPtr<CSSValueList> list = parseTransformOrigin();
         if (!list || list->length() == 3)
             return false;
         // This values are added to match gecko serialization.
         if (list->length() == 1)
             list->append(cssValuePool().createValue(50, CSSPrimitiveValue::CSS_PERCENTAGE));
-        addProperty(propId, list.release(), important);
+        addProperty(propId, list.release());
         return true;
     }
     case CSSPropertyWebkitPerspectiveOrigin: {
         if (m_valueList->size() > 2)
             return false;
         RefPtr<CSSValue> originX = nullptr;
         RefPtr<CSSValue> originY = nullptr;
         parse2ValuesFillPosition(m_valueList, originX, originY);
         if (!originX)
             return false;
-        addProperty(CSSPropertyWebkitPerspectiveOriginX, originX.release(), important);
-        addProperty(CSSPropertyWebkitPerspectiveOriginY, originY.release(), important);
+        addProperty(CSSPropertyWebkitPerspectiveOriginX, originX.release());
+        addProperty(CSSPropertyWebkitPerspectiveOriginY, originY.release());
         return true;
     }
     case CSSPropertyAnimationDelay:
     case CSSPropertyAnimationDirection:
     case CSSPropertyAnimationDuration:
     case CSSPropertyAnimationFillMode:
     case CSSPropertyAnimationName:
     case CSSPropertyAnimationPlayState:
     case CSSPropertyAnimationIterationCount:
     case CSSPropertyAnimationTimingFunction:
     case CSSPropertyTransitionDelay:
     case CSSPropertyTransitionDuration:
     case CSSPropertyTransitionTimingFunction:
     case CSSPropertyTransitionProperty: {
         if (RefPtr<CSSValueList> val = parseAnimationPropertyList(propId)) {
-            addProperty(propId, val.release(), important);
+            addProperty(propId, val.release());
             return true;
         }
         return false;
     }
 
     case CSSPropertyWillChange:
         parsedValue = parseWillChange();
         break;
     // End of CSS3 properties
 
@@ skipping 26 matching lines @@
             m_valueList->next();
         break;
 
         /* shorthand properties */
     case CSSPropertyBackground: {
         // Position must come before color in this array because a plain old "0" is a legal color
         // in quirks mode but it's usually the X coordinate of a position.
         const CSSPropertyID properties[] = { CSSPropertyBackgroundImage, CSSPropertyBackgroundRepeat,
                                    CSSPropertyBackgroundAttachment, CSSPropertyBackgroundPosition, CSSPropertyBackgroundOrigin,
                                    CSSPropertyBackgroundClip, CSSPropertyBackgroundColor, CSSPropertyBackgroundSize };
-        return parseFillShorthand(propId, properties, WTF_ARRAY_LENGTH(properties), important);
+        return parseFillShorthand(propId, properties, WTF_ARRAY_LENGTH(properties));
     }
     case CSSPropertyWebkitMask: {
         const CSSPropertyID properties[] = { CSSPropertyWebkitMaskImage, CSSPropertyWebkitMaskRepeat,
             CSSPropertyWebkitMaskPosition, CSSPropertyWebkitMaskOrigin, CSSPropertyWebkitMaskClip, CSSPropertyWebkitMaskSize };
-        return parseFillShorthand(propId, properties, WTF_ARRAY_LENGTH(properties), important);
+        return parseFillShorthand(propId, properties, WTF_ARRAY_LENGTH(properties));
     }
     case CSSPropertyBorder:
         // [ 'border-width' || 'border-style' || <color> ] | inherit
     {
-        if (parseShorthand(propId, parsingShorthandForProperty(CSSPropertyBorder), important)) {
+        if (parseShorthand(propId, parsingShorthandForProperty(CSSPropertyBorder))) {
             // The CSS3 Borders and Backgrounds specification says that border also resets border-image. It's as
             // though a value of none was specified for the image.
-            addExpandedPropertyForValue(CSSPropertyBorderImage, cssValuePool().createImplicitInitialValue(), important);
+            addExpandedPropertyForValue(CSSPropertyBorderImage, cssValuePool().createImplicitInitialValue());
             return true;
         }
         return false;
     }
     case CSSPropertyBorderTop:
         // [ 'border-top-width' || 'border-style' || <color> ] | inherit
-        return parseShorthand(propId, borderTopShorthand(), important);
+        return parseShorthand(propId, borderTopShorthand());
     case CSSPropertyBorderRight:
         // [ 'border-right-width' || 'border-style' || <color> ] | inherit
-        return parseShorthand(propId, borderRightShorthand(), important);
+        return parseShorthand(propId, borderRightShorthand());
     case CSSPropertyBorderBottom:
         // [ 'border-bottom-width' || 'border-style' || <color> ] | inherit
-        return parseShorthand(propId, borderBottomShorthand(), important);
+        return parseShorthand(propId, borderBottomShorthand());
     case CSSPropertyBorderLeft:
         // [ 'border-left-width' || 'border-style' || <color> ] | inherit
-        return parseShorthand(propId, borderLeftShorthand(), important);
+        return parseShorthand(propId, borderLeftShorthand());
     case CSSPropertyWebkitBorderStart:
-        return parseShorthand(propId, webkitBorderStartShorthand(), important);
+        return parseShorthand(propId, webkitBorderStartShorthand());
     case CSSPropertyWebkitBorderEnd:
-        return parseShorthand(propId, webkitBorderEndShorthand(), important);
+        return parseShorthand(propId, webkitBorderEndShorthand());
     case CSSPropertyWebkitBorderBefore:
-        return parseShorthand(propId, webkitBorderBeforeShorthand(), important);
+        return parseShorthand(propId, webkitBorderBeforeShorthand());
     case CSSPropertyWebkitBorderAfter:
-        return parseShorthand(propId, webkitBorderAfterShorthand(), important);
+        return parseShorthand(propId, webkitBorderAfterShorthand());
     case CSSPropertyOutline:
         // [ 'outline-color' || 'outline-style' || 'outline-width' ] | inherit
-        return parseShorthand(propId, outlineShorthand(), important);
+        return parseShorthand(propId, outlineShorthand());
     case CSSPropertyBorderColor:
         // <color>{1,4} | inherit
-        return parse4Values(propId, borderColorShorthand().properties(), important);
+        return parse4Values(propId, borderColorShorthand().properties());
     case CSSPropertyBorderWidth:
         // <border-width>{1,4} | inherit
-        return parse4Values(propId, borderWidthShorthand().properties(), important);
+        return parse4Values(propId, borderWidthShorthand().properties());
     case CSSPropertyBorderStyle:
         // <border-style>{1,4} | inherit
-        return parse4Values(propId, borderStyleShorthand().properties(), important);
+        return parse4Values(propId, borderStyleShorthand().properties());
     case CSSPropertyMargin:
         // <margin-width>{1,4} | inherit
-        return parse4Values(propId, marginShorthand().properties(), important);
+        return parse4Values(propId, marginShorthand().properties());
     case CSSPropertyPadding:
         // <padding-width>{1,4} | inherit
-        return parse4Values(propId, paddingShorthand().properties(), important);
+        return parse4Values(propId, paddingShorthand().properties());
     case CSSPropertyFlexFlow:
-        return parseShorthand(propId, flexFlowShorthand(), important);
+        return parseShorthand(propId, flexFlowShorthand());
     case CSSPropertyFont:
         // [ [ 'font-style' || 'font-variant' || 'font-weight' ]? 'font-size' [ / 'line-height' ]?
         // 'font-family' ] | inherit
-        return parseFont(important);
+        return parseFont();
     case CSSPropertyListStyle:
-        return parseShorthand(propId, listStyleShorthand(), important);
+        return parseShorthand(propId, listStyleShorthand());
     case CSSPropertyWebkitTextStroke:
-        return parseShorthand(propId, webkitTextStrokeShorthand(), important);
+        return parseShorthand(propId, webkitTextStrokeShorthand());
     case CSSPropertyAnimation:
-        return parseAnimationShorthand(propId, important);
+        return parseAnimationShorthand(propId);
     case CSSPropertyTransition:
-        return parseTransitionShorthand(propId, important);
+        return parseTransitionShorthand(propId);
     case CSSPropertyInvalid:
         return false;
     case CSSPropertyPage:
-        return parsePage(propId, important);
+        return parsePage(propId);
     // CSS Text Layout Module Level 3: Vertical writing support
     case CSSPropertyWebkitTextEmphasis:
-        return parseShorthand(propId, webkitTextEmphasisShorthand(), important);
+        return parseShorthand(propId, webkitTextEmphasisShorthand());
 
     case CSSPropertyWebkitTextEmphasisStyle:
-        return parseTextEmphasisStyle(important);
+        return parseTextEmphasisStyle();
 
     case CSSPropertyWebkitTextOrientation:
         // FIXME: For now just support sideways, sideways-right, upright and vertical-right.
         if (id == CSSValueSideways || id == CSSValueSidewaysRight || id == CSSValueVerticalRight || id == CSSValueUpright)
             validPrimitive = true;
         break;
 
     case CSSPropertyWebkitLineBoxContain:
         if (id == CSSValueNone)
             validPrimitive = true;
         else
-            return parseLineBoxContain(important);
+            return parseLineBoxContain();
         break;
     case CSSPropertyWebkitFontFeatureSettings:
         if (id == CSSValueNormal)
             validPrimitive = true;
         else
-            return parseFontFeatureSettings(important);
+            return parseFontFeatureSettings();
         break;
 
     case CSSPropertyFontVariantLigatures:
         if (id == CSSValueNormal)
             validPrimitive = true;
         else
-            return parseFontVariantLigatures(important);
+            return parseFontVariantLigatures();
         break;
     case CSSPropertyWebkitClipPath:
         if (id == CSSValueNone) {
             validPrimitive = true;
         } else if (value->unit == CSSParserValue::Function) {
             parsedValue = parseBasicShape();
         } else if (value->unit == CSSPrimitiveValue::CSS_URI) {
             parsedValue = CSSPrimitiveValue::create(value->string, CSSPrimitiveValue::CSS_URI);
-            addProperty(propId, parsedValue.release(), important);
+            addProperty(propId, parsedValue.release());
             return true;
         }
         break;
     case CSSPropertyTouchAction:
         parsedValue = parseTouchAction();
         break;
 
     // Properties below are validated inside parseViewportProperty, because we
     // check for parser state. We need to invalidate if someone adds them outside
     // a @viewport rule.
     case CSSPropertyOrientation:
         validPrimitive = false;
         break;
 
     default:
         return false;
     }
 
     if (validPrimitive) {
         parsedValue = parseValidPrimitive(id, value);
         m_valueList->next();
     }
     ASSERT(!m_parsedCalculation);
     if (parsedValue) {
         if (!m_valueList->current() || inShorthand()) {
-            addProperty(propId, parsedValue.release(), important);
+            addProperty(propId, parsedValue.release());
             return true;
         }
     }
     return false;
 }
 
 void CSSPropertyParser::addFillValue(RefPtr<CSSValue>& lval, PassRefPtr<CSSValue> rval)
 {
     if (lval) {
         if (lval->isBaseValueList())
@@ skipping 15 matching lines @@
     if (parserValue->id == CSSValueBorderBox || parserValue->id == CSSValuePaddingBox
         || parserValue->id == CSSValueContentBox) {
         cssValue = cssValuePool().createIdentifierValue(parserValue->id);
         return true;
     }
     return false;
 }
 
 const int cMaxFillProperties = 9;
 
-bool CSSPropertyParser::parseFillShorthand(CSSPropertyID propId, const CSSPropertyID* properties, int numProperties, bool important)
+bool CSSPropertyParser::parseFillShorthand(CSSPropertyID propId, const CSSPropertyID* properties, int numProperties)
 {
     ASSERT(numProperties <= cMaxFillProperties);
     if (numProperties > cMaxFillProperties)
         return false;
 
     ShorthandScope scope(this, propId);
 
     bool parsedProperty[cMaxFillProperties] = { false };
     RefPtr<CSSValue> values[cMaxFillProperties];
 #if ENABLE(OILPAN)
@@ skipping 98 matching lines @@
             if (properties[i] == CSSPropertyBackgroundPosition || properties[i] == CSSPropertyWebkitMaskPosition)
                 addFillValue(positionYValue, cssValuePool().createImplicitInitialValue());
             if (properties[i] == CSSPropertyBackgroundRepeat || properties[i] == CSSPropertyWebkitMaskRepeat)
                 addFillValue(repeatYValue, cssValuePool().createImplicitInitialValue());
             if (properties[i] == CSSPropertyBackgroundOrigin || properties[i] == CSSPropertyWebkitMaskOrigin) {
                 // If background-origin wasn't present, then reset background-clip also.
                 addFillValue(clipValue, cssValuePool().createImplicitInitialValue());
             }
         }
         if (properties[i] == CSSPropertyBackgroundPosition) {
-            addProperty(CSSPropertyBackgroundPositionX, values[i].release(), important);
+            addProperty(CSSPropertyBackgroundPositionX, values[i].release());
             // it's OK to call positionYValue.release() since we only see CSSPropertyBackgroundPosition once
-            addProperty(CSSPropertyBackgroundPositionY, positionYValue.release(), important);
+            addProperty(CSSPropertyBackgroundPositionY, positionYValue.release());
         } else if (properties[i] == CSSPropertyWebkitMaskPosition) {
-            addProperty(CSSPropertyWebkitMaskPositionX, values[i].release(), important);
+            addProperty(CSSPropertyWebkitMaskPositionX, values[i].release());
             // it's OK to call positionYValue.release() since we only see CSSPropertyWebkitMaskPosition once
-            addProperty(CSSPropertyWebkitMaskPositionY, positionYValue.release(), important);
+            addProperty(CSSPropertyWebkitMaskPositionY, positionYValue.release());
         } else if (properties[i] == CSSPropertyBackgroundRepeat) {
-            addProperty(CSSPropertyBackgroundRepeatX, values[i].release(), important);
+            addProperty(CSSPropertyBackgroundRepeatX, values[i].release());
             // it's OK to call repeatYValue.release() since we only see CSSPropertyBackgroundPosition once
-            addProperty(CSSPropertyBackgroundRepeatY, repeatYValue.release(), important);
+            addProperty(CSSPropertyBackgroundRepeatY, repeatYValue.release());
         } else if (properties[i] == CSSPropertyWebkitMaskRepeat) {
-            addProperty(CSSPropertyWebkitMaskRepeatX, values[i].release(), important);
+            addProperty(CSSPropertyWebkitMaskRepeatX, values[i].release());
             // it's OK to call repeatYValue.release() since we only see CSSPropertyBackgroundPosition once
-            addProperty(CSSPropertyWebkitMaskRepeatY, repeatYValue.release(), important);
+            addProperty(CSSPropertyWebkitMaskRepeatY, repeatYValue.release());
         } else if ((properties[i] == CSSPropertyBackgroundClip || properties[i] == CSSPropertyWebkitMaskClip) && !foundClip)
             // Value is already set while updating origin
             continue;
         else
-            addProperty(properties[i], values[i].release(), important);
+            addProperty(properties[i], values[i].release());
 
         // Add in clip values when we hit the corresponding origin property.
         if (properties[i] == CSSPropertyBackgroundOrigin && !foundClip)
-            addProperty(CSSPropertyBackgroundClip, clipValue.release(), important);
+            addProperty(CSSPropertyBackgroundClip, clipValue.release());
         else if (properties[i] == CSSPropertyWebkitMaskOrigin && !foundClip)
-            addProperty(CSSPropertyWebkitMaskClip, clipValue.release(), important);
+            addProperty(CSSPropertyWebkitMaskClip, clipValue.release());
     }
 
     m_implicitShorthand = false;
     return true;
 }
 
 static bool isValidTransitionPropertyList(CSSValueList* value)
 {
     if (value->length() < 2)
         return true;
     for (CSSValueListIterator i = value; i.hasMore(); i.advance()) {
         // FIXME: Shorthand parsing shouldn't add initial to the list since it won't round-trip
         if (i.value()->isInitialValue())
             continue;
         CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(i.value());
         if (primitiveValue->isValueID() && primitiveValue->getValueID() == CSSValueNone)
             return false;
     }
     return true;
 }
 
-bool CSSPropertyParser::parseAnimationShorthand(CSSPropertyID propId, bool important)
+bool CSSPropertyParser::parseAnimationShorthand(CSSPropertyID propId)
 {
     const StylePropertyShorthand& animationProperties = parsingShorthandForProperty(propId);
     const unsigned numProperties = 8;
 
     // The list of properties in the shorthand should be the same
     // length as the list with animation name in last position, even though they are
     // in a different order.
     ASSERT(numProperties == animationProperties.length());
     ASSERT(numProperties == shorthandForProperty(propId).length());
 
@@ skipping 31 matching lines @@
         // invalid shorthand and we have to ignore it
         if (!found)
             return false;
     }
 
     for (size_t i = 0; i < numProperties; ++i) {
         // If we didn't find the property, set an intial value.
         if (!parsedProperty[i])
             values[i]->append(cssValuePool().createImplicitInitialValue());
 
-        addProperty(animationProperties.properties()[i], values[i].release(), important);
+        addProperty(animationProperties.properties()[i], values[i].release());
     }
 
     return true;
 }
 
-bool CSSPropertyParser::parseTransitionShorthand(CSSPropertyID propId, bool important)
+bool CSSPropertyParser::parseTransitionShorthand(CSSPropertyID propId)
 {
     const unsigned numProperties = 4;
     const StylePropertyShorthand& shorthand = parsingShorthandForProperty(propId);
     ASSERT(numProperties == shorthand.length());
 
     ShorthandScope scope(this, propId);
 
     bool parsedProperty[numProperties] = { false };
     RefPtr<CSSValueList> values[numProperties];
     for (size_t i = 0; i < numProperties; ++i)
@@ skipping 29 matching lines @@
     }
 
     ASSERT(shorthand.properties()[3] == CSSPropertyTransitionProperty);
     if (!isValidTransitionPropertyList(values[3].get()))
         return false;
 
     // Fill in any remaining properties with the initial value and add
     for (size_t i = 0; i < numProperties; ++i) {
         if (!parsedProperty[i])
             values[i]->append(cssValuePool().createImplicitInitialValue());
-        addProperty(shorthand.properties()[i], values[i].release(), important);
+        addProperty(shorthand.properties()[i], values[i].release());
     }
 
     return true;
 }
 
-bool CSSPropertyParser::parseShorthand(CSSPropertyID propId, const StylePropertyShorthand& shorthand, bool important)
+bool CSSPropertyParser::parseShorthand(CSSPropertyID propId, const StylePropertyShorthand& shorthand)
 {
     // We try to match as many properties as possible
     // We set up an array of booleans to mark which property has been found,
     // and we try to search for properties until it makes no longer any sense.
     ShorthandScope scope(this, propId);
 
     bool found = false;
     unsigned propertiesParsed = 0;
     bool propertyFound[6] = { false, false, false, false, false, false }; // 6 is enough size.
 
     while (m_valueList->current()) {
         found = false;
         for (unsigned propIndex = 0; !found && propIndex < shorthand.length(); ++propIndex) {
-            if (!propertyFound[propIndex] && parseValue(shorthand.properties()[propIndex], important)) {
+            if (!propertyFound[propIndex] && parseValue(shorthand.properties()[propIndex])) {
                 propertyFound[propIndex] = found = true;
                 propertiesParsed++;
             }
         }
 
         // if we didn't find at least one match, this is an
         // invalid shorthand and we have to ignore it
         if (!found)
             return false;
     }
 
     if (propertiesParsed == shorthand.length())
         return true;
 
     // Fill in any remaining properties with the initial value.
     ImplicitScope implicitScope(this);
     const StylePropertyShorthand* const* const propertiesForInitialization = shorthand.propertiesForInitialization();
     for (unsigned i = 0; i < shorthand.length(); ++i) {
         if (propertyFound[i])
             continue;
 
         if (propertiesForInitialization) {
             const StylePropertyShorthand& initProperties = *(propertiesForInitialization[i]);
             for (unsigned propIndex = 0; propIndex < initProperties.length(); ++propIndex)
-                addProperty(initProperties.properties()[propIndex], cssValuePool().createImplicitInitialValue(), important);
+                addProperty(initProperties.properties()[propIndex], cssValuePool().createImplicitInitialValue());
         } else
-            addProperty(shorthand.properties()[i], cssValuePool().createImplicitInitialValue(), important);
+            addProperty(shorthand.properties()[i], cssValuePool().createImplicitInitialValue());
     }
 
     return true;
 }
 
-bool CSSPropertyParser::parse4Values(CSSPropertyID propId, const CSSPropertyID *properties,  bool important)
+bool CSSPropertyParser::parse4Values(CSSPropertyID propId, const CSSPropertyID *properties)
 {
     /* From the CSS 2 specs, 8.3
      * If there is only one value, it applies to all sides. If there are two values, the top and
      * bottom margins are set to the first value and the right and left margins are set to the second.
      * If there are three values, the top is set to the first value, the left and right are set to the
      * second, and the bottom is set to the third. If there are four values, they apply to the top,
      * right, bottom, and left, respectively.
      */
 
     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))
+            if (!parseValue(properties[0]))
                 return false;
             CSSValue* value = m_parsedProperties.last().value();
             ImplicitScope implicitScope(this);
-            addProperty(properties[1], value, important);
-            addProperty(properties[2], value, important);
-            addProperty(properties[3], value, important);
+            addProperty(properties[1], value);
+            addProperty(properties[2], value);
+            addProperty(properties[3], value);
             break;
         }
         case 2: {
-            if (!parseValue(properties[0], important) || !parseValue(properties[1], important))
+            if (!parseValue(properties[0]) || !parseValue(properties[1]))
                 return false;
             CSSValue* value = m_parsedProperties[m_parsedProperties.size() - 2].value();
             ImplicitScope implicitScope(this);
-            addProperty(properties[2], value, important);
+            addProperty(properties[2], value);
             value = m_parsedProperties[m_parsedProperties.size() - 2].value();
-            addProperty(properties[3], value, important);
+            addProperty(properties[3], value);
             break;
         }
         case 3: {
-            if (!parseValue(properties[0], important) || !parseValue(properties[1], important) || !parseValue(properties[2], important))
+            if (!parseValue(properties[0]) || !parseValue(properties[1]) || !parseValue(properties[2]))
                 return false;
             CSSValue* value = m_parsedProperties[m_parsedProperties.size() - 2].value();
             ImplicitScope implicitScope(this);
-            addProperty(properties[3], value, important);
+            addProperty(properties[3], value);
             break;
         }
         case 4: {
-            if (!parseValue(properties[0], important) || !parseValue(properties[1], important) ||
-                !parseValue(properties[2], important) || !parseValue(properties[3], important))
+            if (!parseValue(properties[0]) || !parseValue(properties[1]) ||
+                !parseValue(properties[2]) || !parseValue(properties[3]))
                 return false;
             break;
         }
         default: {
             return false;
         }
     }
 
     return true;
 }
 
 // auto | <identifier>
-bool CSSPropertyParser::parsePage(CSSPropertyID propId, bool important)
+bool CSSPropertyParser::parsePage(CSSPropertyID propId)
 {
     ASSERT(propId == CSSPropertyPage);
 
     if (m_valueList->size() != 1)
         return false;
 
     CSSParserValue* value = m_valueList->current();
     if (!value)
         return false;
 
     if (value->id == CSSValueAuto) {
-        addProperty(propId, cssValuePool().createIdentifierValue(value->id), important);
+        addProperty(propId, cssValuePool().createIdentifierValue(value->id));
         return true;
     } else if (value->id == 0 && value->unit == CSSPrimitiveValue::CSS_IDENT) {
-        addProperty(propId, createPrimitiveStringValue(value), important);
+        addProperty(propId, createPrimitiveStringValue(value));
         return true;
     }
     return false;
 }
 
 // <length>{1,2} | auto | [ <page-size> || [ portrait | landscape] ]
-bool CSSPropertyParser::parseSize(CSSPropertyID propId, bool important)
+bool CSSPropertyParser::parseSize(CSSPropertyID propId)
 {
     ASSERT(propId == CSSPropertySize);
 
     if (m_valueList->size() > 2)
         return false;
 
     CSSParserValue* value = m_valueList->current();
     if (!value)
         return false;
 
     RefPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
 
     // First parameter.
     SizeParameterType paramType = parseSizeParameter(parsedValues.get(), value, None);
     if (paramType == None)
         return false;
 
     // Second parameter, if any.
     value = m_valueList->next();
     if (value) {
         paramType = parseSizeParameter(parsedValues.get(), value, paramType);
         if (paramType == None)
             return false;
     }
 
-    addProperty(propId, parsedValues.release(), important);
+    addProperty(propId, parsedValues.release());
     return true;
 }
 
 CSSPropertyParser::SizeParameterType CSSPropertyParser::parseSizeParameter(CSSValueList* parsedValues, CSSParserValue* value, SizeParameterType prevParamType)
 {
     switch (value->id) {
     case CSSValueAuto:
         if (prevParamType == None) {
             parsedValues->append(cssValuePool().createIdentifierValue(value->id));
             return Auto;
@@ skipping 792 matching lines @@
         ASSERT(CSSPropertyMetadata::isEnabledProperty(property));
         return cssValuePool().createIdentifierValue(property);
     }
     if (value->id == CSSValueNone)
         return cssValuePool().createIdentifierValue(CSSValueNone);
     if (value->id == CSSValueInitial || value->id == CSSValueInherit)
         return nullptr;
     return createPrimitiveStringValue(value);
 }
 
-bool CSSPropertyParser::parseWebkitTransformOriginShorthand(bool important)
+bool CSSPropertyParser::parseWebkitTransformOriginShorthand()
 {
     RefPtr<CSSValue> originX = nullptr;
     RefPtr<CSSValue> originY = nullptr;
     RefPtr<CSSValue> originZ = nullptr;
 
     parse2ValuesFillPosition(m_valueList, originX, originY);
 
     if (m_valueList->current()) {
         if (!validUnit(m_valueList->current(), FLength))
             return false;
         originZ = createPrimitiveNumericValue(m_valueList->current());
         m_valueList->next();
     } else {
         originZ = cssValuePool().createImplicitInitialValue();
     }
 
-    addProperty(CSSPropertyWebkitTransformOriginX, originX.release(), important);
-    addProperty(CSSPropertyWebkitTransformOriginY, originY.release(), important);
-    addProperty(CSSPropertyWebkitTransformOriginZ, originZ.release(), important);
+    addProperty(CSSPropertyWebkitTransformOriginX, originX.release());
+    addProperty(CSSPropertyWebkitTransformOriginY, originY.release());
+    addProperty(CSSPropertyWebkitTransformOriginZ, originZ.release());
 
     return true;
 }
 
 bool CSSPropertyParser::parseCubicBezierTimingFunctionValue(CSSParserValueList*& args, double& result)
 {
     CSSParserValue* v = args->current();
     if (!validUnit(v, FNumber))
         return false;
     result = v->fValue;
@@ skipping 146 matching lines @@
         return nullptr;
     ASSERT(list->length());
     return list.release();
 }
 
 static inline bool isCSSWideKeyword(CSSParserValue& value)
 {
     return value.id == CSSValueInitial || value.id == CSSValueInherit || value.id == CSSValueDefault;
 }
 
-bool CSSPropertyParser::parseClipShape(CSSPropertyID propId, bool important)
+bool CSSPropertyParser::parseClipShape(CSSPropertyID propId)
 {
     CSSParserValue* value = m_valueList->current();
     CSSParserValueList* args = value->function->args.get();
 
     if (!equalIgnoringCase(value->function->name, "rect(") || !args)
         return false;
 
     // rect(t, r, b, l) || rect(t r b l)
     if (args->size() != 4 && args->size() != 7)
         return false;
@@ skipping 15 matching lines @@
         else
             rect->setLeft(length);
         a = args->next();
         if (a && args->size() == 7) {
             if (!consumeComma(args))
                 return false;
             a = args->current();
         }
         i++;
     }
-    addProperty(propId, cssValuePool().createValue(rect.release()), important);
+    addProperty(propId, cssValuePool().createValue(rect.release()));
     m_valueList->next();
     return true;
 }
 
 static void completeBorderRadii(RefPtr<CSSPrimitiveValue> radii[4])
 {
     if (radii[3])
         return;
     if (!radii[2]) {
         if (!radii[1])
@@ skipping 128 matching lines @@
     return id == CSSValueBaseline || id == CSSValueLastBaseline;
 }
 
 static bool isItemPositionKeyword(CSSValueID id)
 {
     return id == CSSValueStart || id == CSSValueEnd || id == CSSValueCenter
         || id == CSSValueSelfStart || id == CSSValueSelfEnd || id == CSSValueFlexStart
         || id == CSSValueFlexEnd || id == CSSValueLeft || id == CSSValueRight;
 }
 
-bool CSSPropertyParser::parseItemPositionOverflowPosition(CSSPropertyID propId, bool important)
+bool CSSPropertyParser::parseItemPositionOverflowPosition(CSSPropertyID propId)
 {
     // auto | stretch | <baseline-position> | [<item-position> && <overflow-position>? ]
     // <baseline-position> = baseline | last-baseline;
     // <item-position> = center | start | end | self-start | self-end | flex-start | flex-end | left | right;
     // <overflow-position> = true | safe
 
     CSSParserValue* value = m_valueList->current();
     if (!value)
         return false;
 
     if (value->id == CSSValueAuto || value->id == CSSValueStretch || isBaselinePositionKeyword(value->id)) {
         if (m_valueList->next())
             return false;
 
-        addProperty(propId, cssValuePool().createIdentifierValue(value->id), important);
+        addProperty(propId, cssValuePool().createIdentifierValue(value->id));
         return true;
     }
 
     RefPtr<CSSPrimitiveValue> position = nullptr;
     RefPtr<CSSPrimitiveValue> overflowAlignmentKeyword = nullptr;
     if (isItemPositionKeyword(value->id)) {
         position = cssValuePool().createIdentifierValue(value->id);
         value = m_valueList->next();
         if (value) {
             if (value->id == CSSValueTrue || value->id == CSSValueSafe)
@@ skipping 10 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, createPrimitiveValuePair(position, overflowAlignmentKeyword));
     else
-        addProperty(propId, position.release(), important);
+        addProperty(propId, position.release());
 
     return true;
 }
 
 PassRefPtr<CSSPrimitiveValue> CSSPropertyParser::parseShapeRadius(CSSParserValue* value)
 {
     if (value->id == CSSValueClosestSide || value->id == CSSValueFarthestSide)
         return cssValuePool().createIdentifierValue(value->id);
 
     if (!validUnit(value, FLength | FPercent | FNonNeg))
@@ skipping 235 matching lines @@
 
     if (!shape)
         return nullptr;
 
     m_valueList->next();
 
     return cssValuePool().createValue(shape.release());
 }
 
 // [ 'font-style' || 'font-variant' || 'font-weight' ]? 'font-size' [ / 'line-height' ]? 'font-family'
-bool CSSPropertyParser::parseFont(bool important)
+bool CSSPropertyParser::parseFont()
 {
     // Let's check if there is an inherit or initial somewhere in the shorthand.
     for (unsigned i = 0; i < m_valueList->size(); ++i) {
         if (m_valueList->valueAt(i)->id == CSSValueInherit || m_valueList->valueAt(i)->id == CSSValueInitial)
             return false;
     }
 
     ShorthandScope scope(this, CSSPropertyFont);
     // Optional font-style, font-variant and font-weight.
     bool fontStyleParsed = false;
     bool fontVariantParsed = false;
     bool fontWeightParsed = false;
     bool fontStretchParsed = false;
     CSSParserValue* value = m_valueList->current();
     for (; value; value = m_valueList->next()) {
         if (!fontStyleParsed && isValidKeywordPropertyAndValue(CSSPropertyFontStyle, value->id, m_context)) {
-            addProperty(CSSPropertyFontStyle, cssValuePool().createIdentifierValue(value->id), important);
+            addProperty(CSSPropertyFontStyle, cssValuePool().createIdentifierValue(value->id));
             fontStyleParsed = true;
         } else if (!fontVariantParsed && (value->id == CSSValueNormal || value->id == CSSValueSmallCaps)) {
             // Font variant in the shorthand is particular, it only accepts normal or small-caps.
-            addProperty(CSSPropertyFontVariant, cssValuePool().createIdentifierValue(value->id), important);
+            addProperty(CSSPropertyFontVariant, cssValuePool().createIdentifierValue(value->id));
             fontVariantParsed = true;
-        } else if (!fontWeightParsed && parseFontWeight(important)) {
+        } else if (!fontWeightParsed && parseFontWeight()) {
             fontWeightParsed = true;
         } else if (!fontStretchParsed && isValidKeywordPropertyAndValue(CSSPropertyFontStretch, value->id, m_context)) {
-            addProperty(CSSPropertyFontStretch, cssValuePool().createIdentifierValue(value->id), important);
+            addProperty(CSSPropertyFontStretch, cssValuePool().createIdentifierValue(value->id));
             fontStretchParsed = true;
         } else {
             break;
         }
     }
 
     if (!value)
         return false;
 
     if (!fontStyleParsed)
-        addProperty(CSSPropertyFontStyle, cssValuePool().createIdentifierValue(CSSValueNormal), important, true);
+        addProperty(CSSPropertyFontStyle, cssValuePool().createIdentifierValue(CSSValueNormal), true);
     if (!fontVariantParsed)
-        addProperty(CSSPropertyFontVariant, cssValuePool().createIdentifierValue(CSSValueNormal), important, true);
+        addProperty(CSSPropertyFontVariant, cssValuePool().createIdentifierValue(CSSValueNormal), true);
     if (!fontWeightParsed)
-        addProperty(CSSPropertyFontWeight, cssValuePool().createIdentifierValue(CSSValueNormal), important, true);
+        addProperty(CSSPropertyFontWeight, cssValuePool().createIdentifierValue(CSSValueNormal), true);
     if (!fontStretchParsed)
-        addProperty(CSSPropertyFontStretch, cssValuePool().createIdentifierValue(CSSValueNormal), important, true);
+        addProperty(CSSPropertyFontStretch, cssValuePool().createIdentifierValue(CSSValueNormal), true);
 
     // Now a font size _must_ come.
     // <absolute-size> | <relative-size> | <length> | <percentage> | inherit
-    if (!parseFontSize(important))
+    if (!parseFontSize())
         return false;
 
     value = m_valueList->current();
     if (!value)
         return false;
 
     if (isForwardSlashOperator(value)) {
         // The line-height property.
         value = m_valueList->next();
         if (!value)
             return false;
-        if (!parseLineHeight(important))
+        if (!parseLineHeight())
             return false;
     } else
-        addProperty(CSSPropertyLineHeight, cssValuePool().createIdentifierValue(CSSValueNormal), important, true);
+        addProperty(CSSPropertyLineHeight, cssValuePool().createIdentifierValue(CSSValueNormal), true);
 
     // Font family must come now.
     RefPtr<CSSValue> parsedFamilyValue = parseFontFamily();
     if (!parsedFamilyValue)
         return false;
 
-    addProperty(CSSPropertyFontFamily, parsedFamilyValue.release(), important);
+    addProperty(CSSPropertyFontFamily, parsedFamilyValue.release());
 
     // 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;
 }
 
@@ skipping 97 matching lines @@
         else
             break;
     }
     familyBuilder.commit();
 
     if (!list->length())
         list = nullptr;
     return list.release();
 }
 
-bool CSSPropertyParser::parseLineHeight(bool important)
+bool CSSPropertyParser::parseLineHeight()
 {
     CSSParserValue* value = m_valueList->current();
     CSSValueID id = value->id;
     bool validPrimitive = false;
     // normal | <number> | <length> | <percentage> | inherit
     if (id == CSSValueNormal)
         validPrimitive = true;
     else
         validPrimitive = (!id && validUnit(value, FNumber | FLength | FPercent | FNonNeg));
     if (validPrimitive && (!m_valueList->next() || inShorthand()))
-        addProperty(CSSPropertyLineHeight, parseValidPrimitive(id, value), important);
+        addProperty(CSSPropertyLineHeight, parseValidPrimitive(id, value));
     return validPrimitive;
 }
 
-bool CSSPropertyParser::parseFontSize(bool important)
+bool CSSPropertyParser::parseFontSize()
 {
     CSSParserValue* value = m_valueList->current();
     CSSValueID id = value->id;
     bool validPrimitive = false;
     // <absolute-size> | <relative-size> | <length> | <percentage> | inherit
     if (id >= CSSValueXxSmall && id <= CSSValueLarger)
         validPrimitive = true;
     else
         validPrimitive = validUnit(value, FLength | FPercent | FNonNeg);
     if (validPrimitive && (!m_valueList->next() || inShorthand()))
-        addProperty(CSSPropertyFontSize, parseValidPrimitive(id, value), important);
+        addProperty(CSSPropertyFontSize, parseValidPrimitive(id, value));
     return validPrimitive;
 }
 
-bool CSSPropertyParser::parseFontVariant(bool important)
+bool CSSPropertyParser::parseFontVariant()
 {
     RefPtr<CSSValueList> values = nullptr;
     if (m_valueList->size() > 1)
         values = CSSValueList::createCommaSeparated();
     bool expectComma = false;
     for (CSSParserValue* val = m_valueList->current(); val; val = m_valueList->current()) {
         RefPtr<CSSPrimitiveValue> parsedValue = nullptr;
         if (!expectComma) {
             expectComma = true;
             if (val->id == CSSValueNormal || val->id == CSSValueSmallCaps)
@@ skipping 13 matching lines @@
         }
 
         if (!parsedValue)
             return false;
 
         m_valueList->next();
 
         if (values)
             values->append(parsedValue.release());
         else {
-            addProperty(CSSPropertyFontVariant, parsedValue.release(), important);
+            addProperty(CSSPropertyFontVariant, parsedValue.release());
             return true;
         }
     }
 
     if (values && values->length()) {
         if (m_ruleType != CSSRuleSourceData::FONT_FACE_RULE)
             return false;
-        addProperty(CSSPropertyFontVariant, values.release(), important);
+        addProperty(CSSPropertyFontVariant, values.release());
         return true;
     }
 
     return false;
 }
 
-bool CSSPropertyParser::parseFontWeight(bool important)
+bool CSSPropertyParser::parseFontWeight()
 {
     CSSParserValue* value = m_valueList->current();
     if (value->id >= CSSValueNormal && value->id <= CSSValueLighter) {
-        addProperty(CSSPropertyFontWeight, cssValuePool().createIdentifierValue(value->id), important);
+        addProperty(CSSPropertyFontWeight, cssValuePool().createIdentifierValue(value->id));
         return true;
     }
     if (value->unit == CSSPrimitiveValue::CSS_NUMBER) {
         int weight = static_cast<int>(value->fValue);
         if (!(weight % 100) && weight >= 100 && weight <= 900) {
-            addProperty(CSSPropertyFontWeight, cssValuePool().createIdentifierValue(static_cast<CSSValueID>(CSSValue100 + weight / 100 - 1)), important);
+            addProperty(CSSPropertyFontWeight, cssValuePool().createIdentifierValue(static_cast<CSSValueID>(CSSValue100 + weight / 100 - 1)));
             return true;
         }
     }
     return false;
 }
 
 bool CSSPropertyParser::parseFontFaceSrcURI(CSSValueList* valueList)
 {
     RefPtr<CSSFontFaceSrcValue> uriValue(CSSFontFaceSrcValue::create(completeURL(m_valueList->current()->string)));
     uriValue->setReferrer(m_context.referrer());
@@ skipping 807 matching lines @@
     }
 
     return nullptr;
 }
 
 static bool isFlexBasisMiddleArg(double flexGrow, double flexShrink, double unsetValue, int argSize)
 {
     return flexGrow != unsetValue && flexShrink == unsetValue &&  argSize == 3;
 }
 
-bool CSSPropertyParser::parseFlex(CSSParserValueList* args, bool important)
+bool CSSPropertyParser::parseFlex(CSSParserValueList* args)
 {
     if (!args || !args->size() || args->size() > 3)
         return false;
     static const double unsetValue = -1;
     double flexGrow = unsetValue;
     double flexShrink = unsetValue;
     RefPtr<CSSPrimitiveValue> flexBasis = nullptr;
 
     while (CSSParserValue* arg = args->current()) {
         if (validUnit(arg, FNumber | FNonNeg)) {
@@ skipping 17 matching lines @@
         args->next();
     }
 
     if (flexGrow == unsetValue)
         flexGrow = 1;
     if (flexShrink == unsetValue)
         flexShrink = 1;
     if (!flexBasis)
         flexBasis = cssValuePool().createValue(0, CSSPrimitiveValue::CSS_PERCENTAGE);
 
-    addProperty(CSSPropertyFlexGrow, cssValuePool().createValue(clampToFloat(flexGrow), CSSPrimitiveValue::CSS_NUMBER), important);
-    addProperty(CSSPropertyFlexShrink, cssValuePool().createValue(clampToFloat(flexShrink), CSSPrimitiveValue::CSS_NUMBER), important);
-    addProperty(CSSPropertyFlexBasis, flexBasis, important);
+    addProperty(CSSPropertyFlexGrow, cssValuePool().createValue(clampToFloat(flexGrow), CSSPrimitiveValue::CSS_NUMBER));
+    addProperty(CSSPropertyFlexShrink, cssValuePool().createValue(clampToFloat(flexShrink), CSSPrimitiveValue::CSS_NUMBER));
+    addProperty(CSSPropertyFlexBasis, flexBasis);
     return true;
 }
 
 PassRefPtr<CSSValue> CSSPropertyParser::parseObjectPosition()
 {
     RefPtr<CSSValue> xValue = nullptr;
     RefPtr<CSSValue> yValue = nullptr;
     parseFillPosition(m_valueList, xValue, yValue);
     if (!xValue || !yValue)
         return nullptr;
@@ skipping 82 matching lines @@
         m_allowRepeat = m_allowForwardSlashOperator = m_requireWidth = m_requireOutset = false;
         m_allowImageSlice = !m_imageSlice;
         m_allowImage = !m_image;
     }
 
     PassRefPtr<CSSValue> commitCSSValue()
     {
         return createBorderImageValue(m_image, m_imageSlice.get(), m_borderWidth.get(), m_outset.get(), m_repeat.get());
     }
 
-    void commitMaskBoxImage(CSSPropertyParser* parser, bool important)
+    void commitMaskBoxImage(CSSPropertyParser* parser)
     {
-        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageSource, parser, m_image, important);
-        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageSlice, parser, m_imageSlice.get(), important);
-        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageWidth, parser, m_borderWidth.get(), important);
-        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageOutset, parser, m_outset.get(), important);
-        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageRepeat, parser, m_repeat.get(), important);
+        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageSource, parser, m_image);
+        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageSlice, parser, m_imageSlice.get());
+        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageWidth, parser, m_borderWidth.get());
+        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageOutset, parser, m_outset.get());
+        commitBorderImageProperty(CSSPropertyWebkitMaskBoxImageRepeat, parser, m_repeat.get());
     }
 
-    void commitBorderImage(CSSPropertyParser* parser, bool important)
+    void commitBorderImage(CSSPropertyParser* parser)
     {
-        commitBorderImageProperty(CSSPropertyBorderImageSource, parser, m_image, important);
-        commitBorderImageProperty(CSSPropertyBorderImageSlice, parser, m_imageSlice.get(), important);
-        commitBorderImageProperty(CSSPropertyBorderImageWidth, parser, m_borderWidth.get(), important);
-        commitBorderImageProperty(CSSPropertyBorderImageOutset, parser, m_outset.get(), important);
-        commitBorderImageProperty(CSSPropertyBorderImageRepeat, parser, m_repeat, important);
+        commitBorderImageProperty(CSSPropertyBorderImageSource, parser, m_image);
+        commitBorderImageProperty(CSSPropertyBorderImageSlice, parser, m_imageSlice.get());
+        commitBorderImageProperty(CSSPropertyBorderImageWidth, parser, m_borderWidth.get());
+        commitBorderImageProperty(CSSPropertyBorderImageOutset, parser, m_outset.get());
+        commitBorderImageProperty(CSSPropertyBorderImageRepeat, parser, m_repeat);
     }
 
-    void commitBorderImageProperty(CSSPropertyID propId, CSSPropertyParser* parser, PassRefPtr<CSSValue> value, bool important)
+    void commitBorderImageProperty(CSSPropertyID propId, CSSPropertyParser* parser, PassRefPtr<CSSValue> value)
     {
         if (value)
-            parser->addProperty(propId, value, important);
+            parser->addProperty(propId, value);
         else
-            parser->addProperty(propId, cssValuePool().createImplicitInitialValue(), important, true);
+            parser->addProperty(propId, cssValuePool().createImplicitInitialValue(), true);
     }
 
     static bool buildFromParser(CSSPropertyParser&, CSSPropertyID, BorderImageParseContext&);
 
     bool m_canAdvance;
 
     bool m_allowCommit;
     bool m_allowImage;
     bool m_allowImageSlice;
     bool m_allowRepeat;
@@ skipping 64 matching lines @@
 
         if (!context.canAdvance())
             return false;
 
         parser.m_valueList->next();
     }
 
     return context.allowCommit();
 }
 
-bool CSSPropertyParser::parseBorderImageShorthand(CSSPropertyID propId, bool important)
+bool CSSPropertyParser::parseBorderImageShorthand(CSSPropertyID propId)
 {
     BorderImageParseContext context;
     if (BorderImageParseContext::buildFromParser(*this, propId, context)) {
         switch (propId) {
         case CSSPropertyWebkitMaskBoxImage:
-            context.commitMaskBoxImage(this, important);
+            context.commitMaskBoxImage(this);
             return true;
         case CSSPropertyBorderImage:
-            context.commitBorderImage(this, important);
+            context.commitBorderImage(this);
             return true;
         default:
             ASSERT_NOT_REACHED();
             return false;
         }
     }
     return false;
 }
 
 PassRefPtr<CSSValue> CSSPropertyParser::parseBorderImage(CSSPropertyID propId)
@@ skipping 259 matching lines @@
 bool CSSPropertyParser::parseBorderImageWidth(RefPtr<CSSPrimitiveValue>& result)
 {
     return parseBorderImageQuad(FLength | FNumber | FNonNeg | FPercent, result);
 }
 
 bool CSSPropertyParser::parseBorderImageOutset(RefPtr<CSSPrimitiveValue>& result)
 {
     return parseBorderImageQuad(FLength | FNumber | FNonNeg, result);
 }
 
-bool CSSPropertyParser::parseBorderRadius(CSSPropertyID propId, bool important)
+bool CSSPropertyParser::parseBorderRadius(CSSPropertyID propId)
 {
     unsigned num = m_valueList->size();
     if (num > 9)
         return false;
 
     ShorthandScope scope(this, propId);
     RefPtr<CSSPrimitiveValue> radii[2][4];
 #if ENABLE(OILPAN)
     // Zero initialize the array of raw pointers.
     memset(&radii, 0, sizeof(radii));
@@ skipping 35 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, createPrimitiveValuePair(radii[0][0].release(), radii[1][0].release()));
+    addProperty(CSSPropertyBorderTopRightRadius, createPrimitiveValuePair(radii[0][1].release(), radii[1][1].release()));
+    addProperty(CSSPropertyBorderBottomRightRadius, createPrimitiveValuePair(radii[0][2].release(), radii[1][2].release()));
+    addProperty(CSSPropertyBorderBottomLeftRadius, createPrimitiveValuePair(radii[0][3].release(), radii[1][3].release()));
     return true;
 }
 
 PassRefPtr<CSSValue> CSSPropertyParser::parseAspectRatio()
 {
     unsigned num = m_valueList->size();
     if (num == 1 && m_valueList->valueAt(0)->id == CSSValueNone) {
         m_valueList->next();
         return cssValuePool().createIdentifierValue(CSSValueNone);
     }
@@ skipping 711 matching lines @@
         }
         value = m_valueList->next();
     }
 
     if (list->length())
         return list.release();
 
     return nullptr;
 }
 
-void CSSPropertyParser::addTextDecorationProperty(CSSPropertyID propId, PassRefPtr<CSSValue> value, bool important)
+void CSSPropertyParser::addTextDecorationProperty(CSSPropertyID propId, PassRefPtr<CSSValue> value)
 {
-    // The text-decoration-line property takes priority over text-decoration, unless the latter has important priority set.
-    if (propId == CSSPropertyTextDecoration && !important && !inShorthand()) {
+    // The text-decoration-line property takes priority over text-decoration.
+    if (propId == CSSPropertyTextDecoration && !inShorthand()) {
         for (unsigned i = 0; i < m_parsedProperties.size(); ++i) {
             if (m_parsedProperties[i].id() == CSSPropertyTextDecorationLine)
                 return;
         }
     }
-    addProperty(propId, value, important);
+    addProperty(propId, value);
 }
 
-bool CSSPropertyParser::parseTextDecoration(CSSPropertyID propId, bool important)
+bool CSSPropertyParser::parseTextDecoration(CSSPropertyID propId)
 {
     ASSERT(propId != CSSPropertyTextDecorationLine || RuntimeEnabledFeatures::css3TextDecorationsEnabled());
 
     CSSParserValue* value = m_valueList->current();
     if (value && value->id == CSSValueNone) {
-        addTextDecorationProperty(propId, cssValuePool().createIdentifierValue(CSSValueNone), important);
+        addTextDecorationProperty(propId, cssValuePool().createIdentifierValue(CSSValueNone));
         m_valueList->next();
         return true;
     }
 
     RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     bool isValid = true;
     while (isValid && value) {
         switch (value->id) {
         case CSSValueUnderline:
         case CSSValueOverline:
         case CSSValueLineThrough:
         case CSSValueBlink:
             list->append(cssValuePool().createIdentifierValue(value->id));
             break;
         default:
             isValid = false;
             break;
         }
         if (isValid)
             value = m_valueList->next();
     }
 
     // Values are either valid or in shorthand scope.
     if (list->length() && (isValid || inShorthand())) {
-        addTextDecorationProperty(propId, list.release(), important);
+        addTextDecorationProperty(propId, list.release());
         return true;
     }
 
     return false;
 }
 
-bool CSSPropertyParser::parseTextUnderlinePosition(bool important)
+bool CSSPropertyParser::parseTextUnderlinePosition()
 {
     // The text-underline-position property has syntax "auto | [ under || [ left | right ] ]".
     // However, values 'left' and 'right' are not implemented yet, so we will parse syntax
     // "auto | under" for now.
     CSSParserValue* value = m_valueList->current();
     switch (value->id) {
     case CSSValueAuto:
     case CSSValueUnder:
         if (m_valueList->next())
             return false;
-        addProperty(CSSPropertyTextUnderlinePosition, cssValuePool().createIdentifierValue(value->id), important);
+        addProperty(CSSPropertyTextUnderlinePosition, cssValuePool().createIdentifierValue(value->id));
         return true;
     default:
         return false;
     }
 }
 
-bool CSSPropertyParser::parseTextEmphasisStyle(bool important)
+bool CSSPropertyParser::parseTextEmphasisStyle()
 {
     unsigned valueListSize = m_valueList->size();
 
     RefPtr<CSSPrimitiveValue> fill = nullptr;
     RefPtr<CSSPrimitiveValue> shape = nullptr;
 
     for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
         if (value->unit == CSSPrimitiveValue::CSS_STRING) {
             if (fill || shape || (valueListSize != 1 && !inShorthand()))
                 return false;
-            addProperty(CSSPropertyWebkitTextEmphasisStyle, createPrimitiveStringValue(value), important);
+            addProperty(CSSPropertyWebkitTextEmphasisStyle, createPrimitiveStringValue(value));
             m_valueList->next();
             return true;
         }
 
         if (value->id == CSSValueNone) {
             if (fill || shape || (valueListSize != 1 && !inShorthand()))
                 return false;
-            addProperty(CSSPropertyWebkitTextEmphasisStyle, cssValuePool().createIdentifierValue(CSSValueNone), important);
+            addProperty(CSSPropertyWebkitTextEmphasisStyle, cssValuePool().createIdentifierValue(CSSValueNone));
             m_valueList->next();
             return true;
         }
 
         if (value->id == CSSValueOpen || value->id == CSSValueFilled) {
             if (fill)
                 return false;
             fill = cssValuePool().createIdentifierValue(value->id);
         } else if (value->id == CSSValueDot || value->id == CSSValueCircle || value->id == CSSValueDoubleCircle || value->id == CSSValueTriangle || value->id == CSSValueSesame) {
             if (shape)
                 return false;
             shape = cssValuePool().createIdentifierValue(value->id);
         } else if (!inShorthand())
             return false;
         else
             break;
     }
 
     if (fill && shape) {
         RefPtr<CSSValueList> parsedValues = CSSValueList::createSpaceSeparated();
         parsedValues->append(fill.release());
         parsedValues->append(shape.release());
-        addProperty(CSSPropertyWebkitTextEmphasisStyle, parsedValues.release(), important);
+        addProperty(CSSPropertyWebkitTextEmphasisStyle, parsedValues.release());
         return true;
     }
     if (fill) {
-        addProperty(CSSPropertyWebkitTextEmphasisStyle, fill.release(), important);
+        addProperty(CSSPropertyWebkitTextEmphasisStyle, fill.release());
         return true;
     }
     if (shape) {
-        addProperty(CSSPropertyWebkitTextEmphasisStyle, shape.release(), important);
+        addProperty(CSSPropertyWebkitTextEmphasisStyle, shape.release());
         return true;
     }
 
     return false;
 }
 
 PassRefPtr<CSSValue> CSSPropertyParser::parseTextIndent()
 {
     RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
 
@@ skipping 25 matching lines @@
         }
         return nullptr;
     }
 
     if (!hasLengthOrPercentage)
         return nullptr;
 
     return list.release();
 }
 
-bool CSSPropertyParser::parseLineBoxContain(bool important)
+bool CSSPropertyParser::parseLineBoxContain()
 {
     LineBoxContain lineBoxContain = LineBoxContainNone;
 
     for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
         LineBoxContainFlags flag;
         if (value->id == CSSValueBlock) {
             flag = LineBoxContainBlock;
         } else if (value->id == CSSValueInline) {
             flag = LineBoxContainInline;
         } else if (value->id == CSSValueFont) {
             flag = LineBoxContainFont;
         } else if (value->id == CSSValueGlyphs) {
             flag = LineBoxContainGlyphs;
         } else if (value->id == CSSValueReplaced) {
             flag = LineBoxContainReplaced;
         } else if (value->id == CSSValueInlineBox) {
             flag = LineBoxContainInlineBox;
         } else {
             return false;
         }
         if (lineBoxContain & flag)
             return false;
         lineBoxContain |= flag;
     }
 
     if (!lineBoxContain)
         return false;
 
-    addProperty(CSSPropertyWebkitLineBoxContain, CSSLineBoxContainValue::create(lineBoxContain), important);
+    addProperty(CSSPropertyWebkitLineBoxContain, CSSLineBoxContainValue::create(lineBoxContain));
     return true;
 }
 
 bool CSSPropertyParser::parseFontFeatureTag(CSSValueList* settings)
 {
     // Feature tag name consists of 4-letter characters.
     static const unsigned tagNameLength = 4;
 
     CSSParserValue* value = m_valueList->current();
     // Feature tag name comes first
@@ skipping 20 matching lines @@
             m_valueList->next();
         } else if (value->id == CSSValueOn || value->id == CSSValueOff) {
             tagValue = value->id == CSSValueOn;
             m_valueList->next();
         }
     }
     settings->append(CSSFontFeatureValue::create(tag, tagValue));
     return true;
 }
 
-bool CSSPropertyParser::parseFontFeatureSettings(bool important)
+bool CSSPropertyParser::parseFontFeatureSettings()
 {
     if (m_valueList->size() == 1 && m_valueList->current()->id == CSSValueNormal) {
         RefPtr<CSSPrimitiveValue> normalValue = cssValuePool().createIdentifierValue(CSSValueNormal);
         m_valueList->next();
-        addProperty(CSSPropertyWebkitFontFeatureSettings, normalValue.release(), important);
+        addProperty(CSSPropertyWebkitFontFeatureSettings, normalValue.release());
         return true;
     }
 
     RefPtr<CSSValueList> settings = CSSValueList::createCommaSeparated();
     while (true) {
         if (!m_valueList->current() || !parseFontFeatureTag(settings.get()))
             return false;
         if (!m_valueList->current())
             break;
         if (!consumeComma(m_valueList))
             return false;
     }
-    addProperty(CSSPropertyWebkitFontFeatureSettings, settings.release(), important);
+    addProperty(CSSPropertyWebkitFontFeatureSettings, settings.release());
     return true;
 }
 
-bool CSSPropertyParser::parseFontVariantLigatures(bool important)
+bool CSSPropertyParser::parseFontVariantLigatures()
 {
     RefPtr<CSSValueList> ligatureValues = CSSValueList::createSpaceSeparated();
     bool sawCommonLigaturesValue = false;
     bool sawDiscretionaryLigaturesValue = false;
     bool sawHistoricalLigaturesValue = false;
     bool sawContextualLigaturesValue = false;
 
     for (CSSParserValue* value = m_valueList->current(); value; value = m_valueList->next()) {
         if (value->unit != CSSPrimitiveValue::CSS_IDENT)
             return false;
@@ skipping 28 matching lines @@
             ligatureValues->append(cssValuePool().createIdentifierValue(value->id));
             break;
         default:
             return false;
         }
     }
 
     if (!ligatureValues->length())
         return false;
 
-    addProperty(CSSPropertyFontVariantLigatures, ligatureValues.release(), important);
+    addProperty(CSSPropertyFontVariantLigatures, ligatureValues.release());
     return true;
 }
 
 bool CSSPropertyParser::parseCalculation(CSSParserValue* value, ValueRange range)
 {
     ASSERT(isCalculation(value));
 
     CSSParserValueList* args = value->function->args.get();
     if (!args || !args->size())
         return false;
 
     ASSERT(!m_parsedCalculation);
     m_parsedCalculation = CSSCalcValue::create(value->function->name, args, range);
 
     if (!m_parsedCalculation)
         return false;
 
     return true;
 }
 
-bool CSSPropertyParser::parseViewportProperty(CSSPropertyID propId, bool important)
+bool CSSPropertyParser::parseViewportProperty(CSSPropertyID propId)
 {
     ASSERT(RuntimeEnabledFeatures::cssViewportEnabled() || isUASheetBehavior(m_context.mode()));
 
     CSSParserValue* value = m_valueList->current();
     if (!value)
         return false;
 
     CSSValueID id = value->id;
     bool validPrimitive = false;
 
     switch (propId) {
     case CSSPropertyMinWidth: // auto | <length> | <percentage>
     case CSSPropertyMaxWidth:
     case CSSPropertyMinHeight:
     case CSSPropertyMaxHeight:
         if (id == CSSValueAuto)
             validPrimitive = true;
         else
             validPrimitive = (!id && validUnit(value, FLength | FPercent | FNonNeg));
         break;
     case CSSPropertyWidth: // shorthand
-        return parseViewportShorthand(propId, CSSPropertyMinWidth, CSSPropertyMaxWidth, important);
+        return parseViewportShorthand(propId, CSSPropertyMinWidth, CSSPropertyMaxWidth);
     case CSSPropertyHeight:
-        return parseViewportShorthand(propId, CSSPropertyMinHeight, CSSPropertyMaxHeight, important);
+        return parseViewportShorthand(propId, CSSPropertyMinHeight, CSSPropertyMaxHeight);
     case CSSPropertyOrientation: // auto | portrait | landscape
         if (id == CSSValueAuto || id == CSSValuePortrait || id == CSSValueLandscape)
             validPrimitive = true;
     default:
         break;
     }
 
     RefPtr<CSSValue> parsedValue = nullptr;
     if (validPrimitive) {
         parsedValue = parseValidPrimitive(id, value);
         m_valueList->next();
     }
 
     if (parsedValue) {
         if (!m_valueList->current() || inShorthand()) {
-            addProperty(propId, parsedValue.release(), important);
+            addProperty(propId, parsedValue.release());
             return true;
         }
     }
 
     return false;
 }
 
-bool CSSPropertyParser::parseViewportShorthand(CSSPropertyID propId, CSSPropertyID first, CSSPropertyID second, bool important)
+bool CSSPropertyParser::parseViewportShorthand(CSSPropertyID propId, CSSPropertyID first, CSSPropertyID second)
 {
     ASSERT(RuntimeEnabledFeatures::cssViewportEnabled() || isUASheetBehavior(m_context.mode()));
     unsigned numValues = m_valueList->size();
 
     if (numValues > 2)
         return false;
 
     ShorthandScope scope(this, propId);
 
-    if (!parseViewportProperty(first, important))
+    if (!parseViewportProperty(first))
         return false;
 
     // If just one value is supplied, the second value
     // is implicitly initialized with the first value.
     if (numValues == 1)
         m_valueList->previous();
 
-    return parseViewportProperty(second, important);
+    return parseViewportProperty(second);
 }
 
 template <typename CharacterType>
 static CSSPropertyID cssPropertyID(const CharacterType* propertyName, unsigned length)
 {
     char buffer[maxCSSPropertyNameLength + 1]; // 1 for null character
 
     for (unsigned i = 0; i != length; ++i) {
         CharacterType c = propertyName[i];
         if (c == 0 || c >= 0x7F)
@@ skipping 74 matching lines @@
         || equalIgnoringCase(token, "n") || equalIgnoringCase(token, "-n");
 }
 
 bool CSSPropertyParser::isSystemColor(int id)
 {
     // FIXME(sky): remove
     return false;
 }
 
 } // namespace blink