Remove css !important

sky/engine/core/css/StylePropertySerializer.cpp

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Research In Motion Limited. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 25 matching lines @@
     DEFINE_STATIC_LOCAL(String, initial, ("initial"));
     DEFINE_STATIC_LOCAL(String, inherit, ("inherit"));
     return value.length() == 7 && (value == initial || value == inherit);
 }
 
 StylePropertySerializer::StylePropertySerializer(const StylePropertySet& properties)
     : m_propertySet(properties)
 {
 }
 
-String StylePropertySerializer::getPropertyText(CSSPropertyID propertyID, const String& value, bool isImportant, bool isNotFirstDecl) const
+String StylePropertySerializer::getPropertyText(CSSPropertyID propertyID, const String& value, bool isNotFirstDecl) const
 {
     StringBuilder result;
     if (isNotFirstDecl)
         result.append(' ');
     result.append(getPropertyName(propertyID));
     result.appendLiteral(": ");
     result.append(value);
-    if (isImportant)
-        result.appendLiteral(" !important");
     result.append(';');
     return result.toString();
 }
 
 String StylePropertySerializer::asText() const
 {
     StringBuilder result;
 
     BitArray<numCSSProperties> shorthandPropertyUsed;
     BitArray<numCSSProperties> shorthandPropertyAppeared;
@@ skipping 149 matching lines @@
             if (shorthandPropertyID) {
                 propertyID = shorthandPropertyID;
                 shorthandPropertyUsed.set(shortPropertyIndex);
             }
         } else
             value = property.value()->cssText();
 
         if (value == "initial" && !CSSPropertyMetadata::isInheritedProperty(propertyID))
             continue;
 
-        result.append(getPropertyText(propertyID, value, property.isImportant(), numDecls++));
+        result.append(getPropertyText(propertyID, value, numDecls++));
     }
 
     if (shorthandPropertyAppeared.get(CSSPropertyBackground - firstCSSProperty))
         appendBackgroundPropertyAsText(result, numDecls);
 
     ASSERT(!numDecls ^ !result.isEmpty());
     return result.toString();
 }
 
 String StylePropertySerializer::getPropertyValue(CSSPropertyID propertyID) const
@@ skipping 171 matching lines @@
     if (top.isInherited() && right.isInherited() && bottom.isInherited() && left.isInherited())
         return getValueName(CSSValueInherit);
 
     if (top.value()->isInitialValue() || right.value()->isInitialValue() || bottom.value()->isInitialValue() || left.value()->isInitialValue()) {
         if (top.value()->isInitialValue() && right.value()->isInitialValue() && bottom.value()->isInitialValue() && left.value()->isInitialValue() && !top.isImplicit()) {
             // All components are "initial" and "top" is not implicit.
             return getValueName(CSSValueInitial);
         }
         return String();
     }
-    if (top.isImportant() != right.isImportant() || right.isImportant() != bottom.isImportant() || bottom.isImportant() != left.isImportant())
-        return String();
 
     bool showLeft = !right.value()->equals(*left.value());
     bool showBottom = !top.value()->equals(*bottom.value()) || showLeft;
     bool showRight = !top.value()->equals(*right.value()) || showBottom;
 
     StringBuilder result;
     result.append(top.value()->cssText());
     if (showRight) {
         result.append(' ');
         result.append(right.value()->cssText());
@@ skipping 186 matching lines @@
         return commonValue;
     if (result.isEmpty())
         return String();
     return result.toString();
 }
 
 // only returns a non-null value if all properties have the same, non-null value
 String StylePropertySerializer::getCommonValue(const StylePropertyShorthand& shorthand) const
 {
     String res;
-    bool lastPropertyWasImportant = false;
     for (unsigned i = 0; i < shorthand.length(); ++i) {
         RefPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(shorthand.properties()[i]);
         // FIXME: CSSInitialValue::cssText should generate the right value.
         if (!value)
             return String();
         String text = value->cssText();
         if (text.isNull())
             return String();
         if (res.isNull())
             res = text;
         else if (res != text)
             return String();
-
-        bool currentPropertyIsImportant = m_propertySet.propertyIsImportant(shorthand.properties()[i]);
-        if (i && lastPropertyWasImportant != currentPropertyIsImportant)
-            return String();
-        lastPropertyWasImportant = currentPropertyIsImportant;
     }
     return res;
 }
 
 String StylePropertySerializer::borderPropertyValue(CommonValueMode valueMode) const
 {
     const StylePropertyShorthand properties[3] = { borderWidthShorthand(), borderStyleShorthand(), borderColorShorthand() };
     String commonValue;
     StringBuilder result;
     for (size_t i = 0; i < WTF_ARRAY_LENGTH(properties); ++i) {
@@ skipping 39 matching lines @@
         builder.append(repeatY.cssText());
     }
 }
 
 String StylePropertySerializer::backgroundRepeatPropertyValue() const
 {
     RefPtr<CSSValue> repeatX = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundRepeatX);
     RefPtr<CSSValue> repeatY = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundRepeatY);
     if (!repeatX || !repeatY)
         return String();
-    if (m_propertySet.propertyIsImportant(CSSPropertyBackgroundRepeatX) != m_propertySet.propertyIsImportant(CSSPropertyBackgroundRepeatY))
-        return String();
     if (repeatX->cssValueType() == repeatY->cssValueType()
         && (repeatX->cssValueType() == CSSValue::CSS_INITIAL || repeatX->cssValueType() == CSSValue::CSS_INHERIT)) {
         return repeatX->cssText();
     }
 
     RefPtr<CSSValueList> repeatXList;
     if (repeatX->cssValueType() == CSSValue::CSS_PRIMITIVE_VALUE) {
         repeatXList = CSSValueList::createCommaSeparated();
         repeatXList->append(repeatX);
     } else if (repeatX->cssValueType() == CSSValue::CSS_VALUE_LIST) {
@@ skipping 21 matching lines @@
             *repeatXList->item(i % repeatXList->length()),
             *repeatYList->item(i % repeatYList->length()));
     }
     return builder.toString();
 }
 
 void StylePropertySerializer::appendBackgroundPropertyAsText(StringBuilder& result, unsigned& numDecls) const
 {
     if (isPropertyShorthandAvailable(backgroundShorthand())) {
         String backgroundValue = getPropertyValue(CSSPropertyBackground);
-        bool isImportant = m_propertySet.propertyIsImportant(CSSPropertyBackgroundImage);
-        result.append(getPropertyText(CSSPropertyBackground, backgroundValue, isImportant, numDecls++));
+        result.append(getPropertyText(CSSPropertyBackground, backgroundValue, numDecls++));
         return;
     }
     if (shorthandHasOnlyInitialOrInheritedValue(backgroundShorthand())) {
         RefPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundImage);
-        bool isImportant = m_propertySet.propertyIsImportant(CSSPropertyBackgroundImage);
-        result.append(getPropertyText(CSSPropertyBackground, value->cssText(), isImportant, numDecls++));
+        result.append(getPropertyText(CSSPropertyBackground, value->cssText(), numDecls++));
         return;
     }
 
     // backgroundShorthandProperty without layered shorhand properties
     const CSSPropertyID backgroundPropertyIds[] = {
         CSSPropertyBackgroundImage,
         CSSPropertyBackgroundAttachment,
         CSSPropertyBackgroundColor,
         CSSPropertyBackgroundSize,
         CSSPropertyBackgroundOrigin,
         CSSPropertyBackgroundClip
     };
 
     for (unsigned i = 0; i < WTF_ARRAY_LENGTH(backgroundPropertyIds); ++i) {
         CSSPropertyID propertyID = backgroundPropertyIds[i];
         RefPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(propertyID);
         if (!value)
             continue;
-        result.append(getPropertyText(propertyID, value->cssText(), m_propertySet.propertyIsImportant(propertyID), numDecls++));
+        result.append(getPropertyText(propertyID, value->cssText(), numDecls++));
     }
 
     // FIXME: This is a not-so-nice way to turn x/y positions into single background-position in output.
     // It is required because background-position-x/y are non-standard properties and WebKit generated output
     // would not work in Firefox (<rdar://problem/5143183>)
     // It would be a better solution if background-position was CSS_PAIR.
     if (shorthandHasOnlyInitialOrInheritedValue(backgroundPositionShorthand())) {
         RefPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundPositionX);
-        bool isImportant = m_propertySet.propertyIsImportant(CSSPropertyBackgroundPositionX);
-        result.append(getPropertyText(CSSPropertyBackgroundPosition, value->cssText(), isImportant, numDecls++));
+        result.append(getPropertyText(CSSPropertyBackgroundPosition, value->cssText(), numDecls++));
     } else if (isPropertyShorthandAvailable(backgroundPositionShorthand())) {
         String positionValue = m_propertySet.getPropertyValue(CSSPropertyBackgroundPosition);
-        bool isImportant = m_propertySet.propertyIsImportant(CSSPropertyBackgroundPositionX);
         if (!positionValue.isNull())
-            result.append(getPropertyText(CSSPropertyBackgroundPosition, positionValue, isImportant, numDecls++));
+            result.append(getPropertyText(CSSPropertyBackgroundPosition, positionValue, numDecls++));
     } else {
         // should check background-position-x or background-position-y.
         if (RefPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundPositionX)) {
             if (!value->isImplicitInitialValue()) {
-                bool isImportant = m_propertySet.propertyIsImportant(CSSPropertyBackgroundPositionX);
-                result.append(getPropertyText(CSSPropertyBackgroundPositionX, value->cssText(), isImportant, numDecls++));
+                result.append(getPropertyText(CSSPropertyBackgroundPositionX, value->cssText(), numDecls++));
             }
         }
         if (RefPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(CSSPropertyBackgroundPositionY)) {
             if (!value->isImplicitInitialValue()) {
-                bool isImportant = m_propertySet.propertyIsImportant(CSSPropertyBackgroundPositionY);
-                result.append(getPropertyText(CSSPropertyBackgroundPositionY, value->cssText(), isImportant, numDecls++));
+                result.append(getPropertyText(CSSPropertyBackgroundPositionY, value->cssText(), numDecls++));
             }
         }
     }
 
     String repeatValue = m_propertySet.getPropertyValue(CSSPropertyBackgroundRepeat);
     if (!repeatValue.isNull())
-        result.append(getPropertyText(CSSPropertyBackgroundRepeat, repeatValue, m_propertySet.propertyIsImportant(CSSPropertyBackgroundRepeatX), numDecls++));
+        result.append(getPropertyText(CSSPropertyBackgroundRepeat, repeatValue, numDecls++));
 }
 
 bool StylePropertySerializer::isPropertyShorthandAvailable(const StylePropertyShorthand& shorthand) const
 {
     ASSERT(shorthand.length() > 0);
 
-    bool isImportant = m_propertySet.propertyIsImportant(shorthand.properties()[0]);
     for (unsigned i = 0; i < shorthand.length(); ++i) {
         RefPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(shorthand.properties()[i]);
         if (!value || (value->isInitialValue() && !value->isImplicitInitialValue()) || value->isInheritedValue())
             return false;
-        if (isImportant != m_propertySet.propertyIsImportant(shorthand.properties()[i]))
-            return false;
     }
     return true;
 }
 
 bool StylePropertySerializer::shorthandHasOnlyInitialOrInheritedValue(const StylePropertyShorthand& shorthand) const
 {
     ASSERT(shorthand.length() > 0);
-    bool isImportant = m_propertySet.propertyIsImportant(shorthand.properties()[0]);
     bool isInitialValue = true;
     bool isInheritedValue = true;
     for (unsigned i = 0; i < shorthand.length(); ++i) {
         RefPtr<CSSValue> value = m_propertySet.getPropertyCSSValue(shorthand.properties()[i]);
         if (!value)
             return false;
         if (!value->isInitialValue())
             isInitialValue = false;
         if (!value->isInheritedValue())
             isInheritedValue = false;
-        if (isImportant != m_propertySet.propertyIsImportant(shorthand.properties()[i]))
-            return false;
     }
     return isInitialValue || isInheritedValue;
 }
 
 }