Remove css !important

sky/engine/core/css/parser/BisonCSSParser-in.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 80 matching lines @@
 int cssyyparse(blink::BisonCSSParser*);
 
 using namespace WTF;
 
 namespace blink {
 
 static const unsigned INVALID_NUM_PARSED_PROPERTIES = UINT_MAX;
 
 BisonCSSParser::BisonCSSParser(const CSSParserContext& context)
     : m_context(context)
-    , m_important(false)
     , m_id(CSSPropertyInvalid)
     , m_styleSheet(nullptr)
     , m_supportsCondition(false)
     , m_selectorListForParseSelector(0)
     , m_numParsedPropertiesBeforeMarginBox(INVALID_NUM_PARSED_PROPERTIES)
     , m_hadSyntacticallyValidCSSRule(false)
     , m_ignoreErrors(false)
     , m_defaultNamespace(starAtom)
     , m_observer(0)
     , m_source(0)
@@ skipping 92 matching lines @@
     case CSSPropertyWebkitTextEmphasisColor:
     case CSSPropertyWebkitTextFillColor:
     case CSSPropertyWebkitTextStrokeColor:
     case CSSPropertyTextDecorationColor:
         return true;
     default:
         return false;
     }
 }
 
-static bool parseColorValue(MutableStylePropertySet* declaration, CSSPropertyID propertyId, const String& string, bool important, CSSParserMode cssParserMode)
+static bool parseColorValue(MutableStylePropertySet* declaration, CSSPropertyID propertyId, const String& string, CSSParserMode cssParserMode)
 {
     ASSERT(!string.isEmpty());
     bool quirksMode = isQuirksModeBehavior(cssParserMode);
     if (!isColorPropertyID(propertyId))
         return false;
     CSSParserString cssString;
     cssString.init(string);
     CSSValueID valueID = cssValueKeywordID(cssString);
     bool validPrimitive = false;
     if (valueID == CSSValueCurrentcolor)
         validPrimitive = true;
 
     if (validPrimitive) {
         RefPtr<CSSValue> value = cssValuePool().createIdentifierValue(valueID);
-        declaration->addParsedProperty(CSSProperty(propertyId, value.release(), important));
+        declaration->addParsedProperty(CSSProperty(propertyId, value.release()));
         return true;
     }
     RGBA32 color;
     if (!CSSPropertyParser::fastParseColor(color, string, !quirksMode && string[0] != '#'))
         return false;
     RefPtr<CSSValue> value = cssValuePool().createColorValue(color);
-    declaration->addParsedProperty(CSSProperty(propertyId, value.release(), important));
+    declaration->addParsedProperty(CSSProperty(propertyId, value.release()));
     return true;
 }
 
 static inline bool isSimpleLengthPropertyID(CSSPropertyID propertyId, bool& acceptsNegativeNumbers)
 {
     switch (propertyId) {
     case CSSPropertyFontSize:
     case CSSPropertyHeight:
     case CSSPropertyWidth:
     case CSSPropertyMinHeight:
@@ skipping 43 matching lines @@
     }
 
     // We rely on charactersToDouble for validation as well. The function
     // will set "ok" to "false" if the entire passed-in character range does
     // not represent a double.
     bool ok;
     number = charactersToDouble(characters, length, &ok);
     return ok;
 }
 
-static bool parseSimpleLengthValue(MutableStylePropertySet* declaration, CSSPropertyID propertyId, const String& string, bool important, CSSParserMode cssParserMode)
+static bool parseSimpleLengthValue(MutableStylePropertySet* declaration, CSSPropertyID propertyId, const String& string, CSSParserMode cssParserMode)
 {
     ASSERT(!string.isEmpty());
     bool acceptsNegativeNumbers = false;
 
     // In @viewport, width and height are shorthands, not simple length values.
     if (isCSSViewportParsingEnabledForMode(cssParserMode) || !isSimpleLengthPropertyID(propertyId, acceptsNegativeNumbers))
         return false;
 
     unsigned length = string.length();
     double number;
@@ skipping 10 matching lines @@
     if (unit == CSSPrimitiveValue::CSS_NUMBER) {
         bool quirksMode = isQuirksModeBehavior(cssParserMode);
         if (number && !quirksMode)
             return false;
         unit = CSSPrimitiveValue::CSS_PX;
     }
     if (number < 0 && !acceptsNegativeNumbers)
         return false;
 
     RefPtr<CSSValue> value = cssValuePool().createValue(number, unit);
-    declaration->addParsedProperty(CSSProperty(propertyId, value.release(), important));
+    declaration->addParsedProperty(CSSProperty(propertyId, value.release()));
     return true;
 }
 
 bool isValidKeywordPropertyAndValue(CSSPropertyID propertyId, CSSValueID valueID, const CSSParserContext& parserContext)
 {
     if (valueID == CSSValueInvalid)
         return false;
 
     switch (propertyId) {
     case CSSPropertyAll:
@@ skipping 203 matching lines @@
     case CSSPropertyWebkitUserSelect:
     case CSSPropertyWhiteSpace:
     case CSSPropertyWordBreak:
     case CSSPropertyWordWrap:
         return true;
     default:
         return false;
     }
 }
 
-static bool parseKeywordValue(MutableStylePropertySet* declaration, CSSPropertyID propertyId, const String& string, bool important, const CSSParserContext& parserContext)
+static bool parseKeywordValue(MutableStylePropertySet* declaration, CSSPropertyID propertyId, const String& string, const CSSParserContext& parserContext)
 {
     ASSERT(!string.isEmpty());
 
     if (!isKeywordPropertyID(propertyId)) {
         // All properties accept the values of "initial" and "inherit".
         String lowerCaseString = string.lower();
         if (lowerCaseString != "initial" && lowerCaseString != "inherit")
             return false;
 
         // Parse initial/inherit shorthands using the BisonCSSParser.
@@ skipping 11 matching lines @@
     RefPtr<CSSValue> value = nullptr;
     if (valueID == CSSValueInherit)
         value = cssValuePool().createInheritedValue();
     else if (valueID == CSSValueInitial)
         value = cssValuePool().createExplicitInitialValue();
     else if (isValidKeywordPropertyAndValue(propertyId, valueID, parserContext))
         value = cssValuePool().createIdentifierValue(valueID);
     else
         return false;
 
-    declaration->addParsedProperty(CSSProperty(propertyId, value.release(), important));
+    declaration->addParsedProperty(CSSProperty(propertyId, value.release()));
     return true;
 }
 
 template <typename CharType>
 static bool parseTransformTranslateArguments(CharType*& pos, CharType* end, unsigned expectedCount, CSSTransformValue* transformValue)
 {
     while (expectedCount) {
         size_t delimiter = WTF::find(pos, end - pos, expectedCount == 1 ? ')' : ',');
         if (delimiter == kNotFound)
             return false;
@@ skipping 129 matching lines @@
             transformList = CSSValueList::createSpaceSeparated();
         transformList->append(transformValue.release());
         if (pos < end) {
             if (isCSSSpace(*pos))
                 return nullptr;
         }
     }
     return transformList.release();
 }
 
-static bool parseSimpleTransform(MutableStylePropertySet* properties, CSSPropertyID propertyID, const String& string, bool important)
+static bool parseSimpleTransform(MutableStylePropertySet* properties, CSSPropertyID propertyID, const String& string)
 {
     if (propertyID != CSSPropertyTransform && propertyID != CSSPropertyWebkitTransform)
         return false;
     if (string.isEmpty())
         return false;
     RefPtr<CSSValueList> transformList = nullptr;
     if (string.is8Bit()) {
         const LChar* pos = string.characters8();
         const LChar* end = pos + string.length();
         transformList = parseSimpleTransformList(pos, end);
         if (!transformList)
             return false;
     } else {
         const UChar* pos = string.characters16();
         const UChar* end = pos + string.length();
         transformList = parseSimpleTransformList(pos, end);
         if (!transformList)
             return false;
     }
-    properties->addParsedProperty(CSSProperty(propertyID, transformList.release(), important));
+    properties->addParsedProperty(CSSProperty(propertyID, transformList.release()));
     return true;
 }
 
 PassRefPtr<CSSValueList> BisonCSSParser::parseFontFaceValue(const AtomicString& string)
 {
     if (string.isEmpty())
         return nullptr;
     RefPtr<MutableStylePropertySet> dummyStyle = MutableStylePropertySet::create();
-    if (!parseValue(dummyStyle.get(), CSSPropertyFontFamily, string, false, HTMLStandardMode, 0))
+    if (!parseValue(dummyStyle.get(), CSSPropertyFontFamily, string, HTMLStandardMode, 0))
         return nullptr;
 
     RefPtr<CSSValue> fontFamily = dummyStyle->getPropertyCSSValue(CSSPropertyFontFamily);
     if (!fontFamily->isValueList())
         return nullptr;
 
     return toCSSValueList(dummyStyle->getPropertyCSSValue(CSSPropertyFontFamily).get());
 }
 
 PassRefPtr<CSSValue> BisonCSSParser::parseAnimationTimingFunctionValue(const String& string)
 {
     if (string.isEmpty())
         return nullptr;
     RefPtr<MutableStylePropertySet> style = MutableStylePropertySet::create();
-    if (!parseValue(style.get(), CSSPropertyTransitionTimingFunction, string, false, HTMLStandardMode, 0))
+    if (!parseValue(style.get(), CSSPropertyTransitionTimingFunction, string, HTMLStandardMode, 0))
         return nullptr;
 
     RefPtr<CSSValue> value = style->getPropertyCSSValue(CSSPropertyTransitionTimingFunction);
     if (!value || value->isInitialValue() || value->isInheritedValue())
         return nullptr;
     CSSValueList* valueList = toCSSValueList(value.get());
     if (valueList->length() > 1)
         return nullptr;
     return valueList->item(0);
 }
 
-bool BisonCSSParser::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, bool important, const Document& document)
+bool BisonCSSParser::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, const Document& document)
 {
     ASSERT(!string.isEmpty());
 
     CSSParserContext context(document, UseCounter::getFrom(&document));
 
-    if (parseSimpleLengthValue(declaration, propertyID, string, important, context.mode()))
+    if (parseSimpleLengthValue(declaration, propertyID, string, context.mode()))
         return true;
-    if (parseColorValue(declaration, propertyID, string, important, context.mode()))
+    if (parseColorValue(declaration, propertyID, string, context.mode()))
         return true;
-    if (parseKeywordValue(declaration, propertyID, string, important, context))
+    if (parseKeywordValue(declaration, propertyID, string, context))
         return true;
 
     BisonCSSParser parser(context);
-    return parser.parseValue(declaration, propertyID, string, important, static_cast<StyleSheetContents*>(0));
+    return parser.parseValue(declaration, propertyID, string, static_cast<StyleSheetContents*>(0));
 }
 
-bool BisonCSSParser::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, bool important, CSSParserMode cssParserMode, StyleSheetContents* contextStyleSheet)
+bool BisonCSSParser::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, CSSParserMode cssParserMode, StyleSheetContents* contextStyleSheet)
 {
     ASSERT(!string.isEmpty());
-    if (parseSimpleLengthValue(declaration, propertyID, string, important, cssParserMode))
+    if (parseSimpleLengthValue(declaration, propertyID, string, cssParserMode))
         return true;
-    if (parseColorValue(declaration, propertyID, string, important, cssParserMode))
+    if (parseColorValue(declaration, propertyID, string, cssParserMode))
         return true;
 
     CSSParserContext context(0); // FIXME: Why does this not have a UseCounter?
     if (contextStyleSheet) {
         context = contextStyleSheet->parserContext();
     }
 
-    if (parseKeywordValue(declaration, propertyID, string, important, context))
+    if (parseKeywordValue(declaration, propertyID, string, context))
         return true;
-    if (parseSimpleTransform(declaration, propertyID, string, important))
+    if (parseSimpleTransform(declaration, propertyID, string))
         return true;
 
     BisonCSSParser parser(context);
-    return parser.parseValue(declaration, propertyID, string, important, contextStyleSheet);
+    return parser.parseValue(declaration, propertyID, string, contextStyleSheet);
 }
 
-bool BisonCSSParser::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, bool important, StyleSheetContents* contextStyleSheet)
+bool BisonCSSParser::parseValue(MutableStylePropertySet* declaration, CSSPropertyID propertyID, const String& string, StyleSheetContents* contextStyleSheet)
 {
     if (m_context.useCounter())
         m_context.useCounter()->count(m_context, propertyID);
 
     setStyleSheet(contextStyleSheet);
 
     setupParser("@-internal-value ", string, "");
 
     m_id = propertyID;
-    m_important = important;
 
     cssyyparse(this);
 
     m_rule = nullptr;
     m_id = CSSPropertyInvalid;
 
     bool ok = false;
     if (!m_parsedProperties.isEmpty()) {
         ok = true;
         declaration->addParsedProperties(m_parsedProperties);
@@ skipping 127 matching lines @@
 {
     if (!RuntimeEnabledFeatures::cssAttributeCaseSensitivityEnabled() && !isUASheetBehavior(m_context.mode()))
         return false;
     if (string == "i") {
         matchType = CSSSelector::CaseInsensitive;
         return true;
     }
     return false;
 }
 
-static inline void filterProperties(bool important, const Vector<CSSProperty, 256>& input, Vector<CSSProperty, 256>& output, size_t& unusedEntries, BitArray<numCSSProperties>& seenProperties)
+static inline void filterProperties(const Vector<CSSProperty, 256>& input, Vector<CSSProperty, 256>& output, size_t& unusedEntries, BitArray<numCSSProperties>& seenProperties)
 {
     // Add properties in reverse order so that highest priority definitions are reached first. Duplicate definitions can then be ignored when found.
     for (int i = input.size() - 1; i >= 0; --i) {
         const CSSProperty& property = input[i];
-        if (property.isImportant() != important)
-            continue;
         const unsigned propertyIDIndex = property.id() - firstCSSProperty;
         if (seenProperties.get(propertyIDIndex))
             continue;
         seenProperties.set(propertyIDIndex);
         output[--unusedEntries] = property;
     }
 }
 
 PassRefPtr<ImmutableStylePropertySet> BisonCSSParser::createStylePropertySet()
 {
     BitArray<numCSSProperties> seenProperties;
     size_t unusedEntries = m_parsedProperties.size();
     Vector<CSSProperty, 256> results(unusedEntries);
 
-    // Important properties have higher priority, so add them first. Duplicate definitions can then be ignored when found.
-    filterProperties(true, m_parsedProperties, results, unusedEntries, seenProperties);
-    filterProperties(false, m_parsedProperties, results, unusedEntries, seenProperties);
+    filterProperties(m_parsedProperties, results, unusedEntries, seenProperties);
     if (unusedEntries)
         results.remove(0, unusedEntries);
 
     return ImmutableStylePropertySet::create(results.data(), results.size(), HTMLStandardMode);
 }
 
 void BisonCSSParser::rollbackLastProperties(int num)
 {
     ASSERT(num >= 0);
     ASSERT(m_parsedProperties.size() >= static_cast<unsigned>(num));
     m_parsedProperties.shrink(m_parsedProperties.size() - num);
 }
 
 void BisonCSSParser::clearProperties()
 {
     m_parsedProperties.clear();
     m_numParsedPropertiesBeforeMarginBox = INVALID_NUM_PARSED_PROPERTIES;
 }
 
 void BisonCSSParser::setCurrentProperty(CSSPropertyID propId)
 {
     m_id = propId;
 }
 
-bool BisonCSSParser::parseValue(CSSPropertyID propId, bool important)
+bool BisonCSSParser::parseValue(CSSPropertyID propId)
 {
-    return CSSPropertyParser::parseValue(propId, important, m_valueList.get(), m_context, m_inViewport, m_parsedProperties, m_ruleHeaderType);
+    return CSSPropertyParser::parseValue(propId, m_valueList.get(), m_context, m_inViewport, m_parsedProperties, m_ruleHeaderType);
 }
 
 
 class TransformOperationInfo {
 public:
     TransformOperationInfo(const CSSParserString& name)
         : m_type(CSSTransformValue::UnknownTransformOperation)
         , m_argCount(1)
         , m_allowSingleArgument(false)
         , m_unit(CSSPropertyParser::FUnknown)
@@ skipping 632 matching lines @@
     if (m_observer)
         m_observer->startRuleBody(m_tokenizer.safeUserStringTokenOffset());
 }
 
 void BisonCSSParser::startProperty()
 {
     if (m_observer)
         m_observer->startProperty(m_tokenizer.safeUserStringTokenOffset());
 }
 
-void BisonCSSParser::endProperty(bool isImportantFound, bool isPropertyParsed, CSSParserError errorType)
+void BisonCSSParser::endProperty(bool isPropertyParsed, CSSParserError errorType)
 {
     m_id = CSSPropertyInvalid;
     if (m_observer)
-        m_observer->endProperty(isImportantFound, isPropertyParsed, m_tokenizer.safeUserStringTokenOffset(), errorType);
+        m_observer->endProperty(isPropertyParsed, m_tokenizer.safeUserStringTokenOffset(), errorType);
 }
 
 void BisonCSSParser::startEndUnknownRule()
 {
     if (m_observer)
         m_observer->startEndUnknownRule();
 }
 
 }