Remove css !important

sky/engine/core/css/resolver/StyleResolver.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 218 matching lines @@
 
         applyMatchedProperties(state, collector.matchedResult());
     }
 
     // Cache our original display.
     state.style()->setOriginalDisplay(state.style()->display());
 
     StyleAdjuster adjuster;
     adjuster.adjustRenderStyle(state.style(), state.parentStyle(), *element);
 
-    // FIXME: The CSSWG wants to specify that the effects of animations are applied before
-    // important rules, but this currently happens here as we require adjustment to have happened
-    // before deciding which properties to transition.
     if (applyAnimatedProperties(state, element))
         adjuster.adjustRenderStyle(state.style(), state.parentStyle(), *element);
 
     setAnimationUpdateIfNeeded(state, *element);
 
     if (state.style()->hasViewportUnits())
         m_document.setHasViewportUnits();
 
     // Now return the style.
     return state.takeStyle();
@@ skipping 12 matching lines @@
     result.addMatchedProperties(&keyframe->properties());
 
     ASSERT(!state.style());
 
     // Create the style
     state.setStyle(RenderStyle::clone(&elementStyle));
     state.setLineHeightValue(0);
 
     state.fontBuilder().initForStyleResolve(state.document(), state.style());
 
-    // We don't need to bother with !important. Since there is only ever one
-    // decl, there's nothing to override. So just add the first properties.
     // We also don't need to bother with animation properties since the only
     // relevant one is animation-timing-function and we special-case that in
     // CSSAnimations.cpp
     bool inheritedOnly = false;
-    applyMatchedProperties<HighPriorityProperties>(state, result, false, inheritedOnly);
+    applyMatchedProperties<HighPriorityProperties>(state, result, inheritedOnly);
 
     // If our font got dirtied, go ahead and update it now.
     updateFont(state);
 
     // Line-height is set when we are sure we decided on the font-size
     if (state.lineHeightValue())
         StyleBuilder::applyProperty(CSSPropertyLineHeight, state, state.lineHeightValue());
 
     // Now do rest of the properties.
-    applyMatchedProperties<LowPriorityProperties>(state, result, false, inheritedOnly);
+    applyMatchedProperties<LowPriorityProperties>(state, result, inheritedOnly);
 
     loadPendingResources(state);
 
     return state.takeStyle();
 }
 
 // This function is used by the WebAnimations JavaScript API method animate().
 // FIXME: Remove this when animate() switches away from resolution-dependent parsing.
 PassRefPtr<AnimatableValue> StyleResolver::createAnimatableValueSnapshot(Element& element, CSSPropertyID property, CSSValue& value)
 {
@@ skipping 180 matching lines @@
             if (CSSPropertyMetadata::isInheritedProperty(propertyId))
                 value = cssValuePool().createInheritedValue().get();
             else
                 value = cssValuePool().createExplicitInitialValue().get();
         }
         StyleBuilder::applyProperty(propertyId, state, value);
     }
 }
 
 template <StyleResolver::StyleApplicationPass pass>
-void StyleResolver::applyProperties(StyleResolverState& state, const StylePropertySet* properties, bool isImportant, bool inheritedOnly)
+void StyleResolver::applyProperties(StyleResolverState& state, const StylePropertySet* properties, bool inheritedOnly)
 {
     unsigned propertyCount = properties->propertyCount();
     for (unsigned i = 0; i < propertyCount; ++i) {
         StylePropertySet::PropertyReference current = properties->propertyAt(i);
-        if (isImportant != current.isImportant())
-            continue;
 
         CSSPropertyID property = current.id();
         if (property == CSSPropertyAll) {
             applyAllProperty<pass>(state, current.value());
             continue;
         }
 
         if (inheritedOnly && !current.isInherited()) {
             // If the property value is explicitly inherited, we need to apply further non-inherited properties
             // as they might override the value inherited here. For this reason we don't allow declarations with
             // explicitly inherited properties to be cached.
             ASSERT(!current.value()->isInheritedValue());
             continue;
         }
 
         if (!isPropertyForPass<pass>(property))
             continue;
         if (pass == HighPriorityProperties && property == CSSPropertyLineHeight)
             state.setLineHeightValue(current.value());
         else
             StyleBuilder::applyProperty(current.id(), state, current.value());
     }
 }
 
 template <StyleResolver::StyleApplicationPass pass>
-void StyleResolver::applyMatchedProperties(StyleResolverState& state, const MatchResult& matchResult, bool isImportant, bool inheritedOnly)
+void StyleResolver::applyMatchedProperties(StyleResolverState& state, const MatchResult& matchResult, bool inheritedOnly)
 {
     for (const RefPtr<StylePropertySet>& properties : matchResult.matchedProperties) {
-        applyProperties<pass>(state, properties.get(), isImportant, inheritedOnly);
+        applyProperties<pass>(state, properties.get(), inheritedOnly);
     }
 }
 
 static unsigned computeMatchedPropertiesHash(const RefPtr<StylePropertySet>* properties, unsigned size)
 {
     return StringHasher::hashMemory(properties, sizeof(*properties) * size);
 }
 
 void StyleResolver::invalidateMatchedPropertiesCache()
 {
@@ skipping 28 matching lines @@
 
             // If the cache item parent style has identical inherited properties to the current parent style then the
             // resulting style will be identical too. We copy the inherited properties over from the cache and are done.
             state.style()->inheritFrom(cachedMatchedProperties->renderStyle.get());
 
             return;
         }
         applyInheritedOnly = true;
     }
 
-    // Now we have all of the matched rules in the appropriate order. Walk the rules and apply
-    // high-priority properties first, i.e., those properties that other properties depend on.
-    // The order is (1) high-priority not important, (2) high-priority important, (3) normal not important
-    // and (4) normal important.
     state.setLineHeightValue(0);
-    applyMatchedProperties<HighPriorityProperties>(state, matchResult, false, applyInheritedOnly);
-    applyMatchedProperties<HighPriorityProperties>(state, matchResult, true, applyInheritedOnly);
+    applyMatchedProperties<HighPriorityProperties>(state, matchResult, applyInheritedOnly);
 
     // If our font got dirtied, go ahead and update it now.
     updateFont(state);
 
     // Line-height is set when we are sure we decided on the font-size.
     if (state.lineHeightValue())
         StyleBuilder::applyProperty(CSSPropertyLineHeight, state, state.lineHeightValue());
 
     // Many properties depend on the font. If it changes we just apply all properties.
     if (cachedMatchedProperties && cachedMatchedProperties->renderStyle->fontDescription() != state.style()->fontDescription())
         applyInheritedOnly = false;
 
-    // Now do the author and user normal priority properties and all the !important properties.
-    applyMatchedProperties<LowPriorityProperties>(state, matchResult, false, applyInheritedOnly);
-    applyMatchedProperties<LowPriorityProperties>(state, matchResult, true, applyInheritedOnly);
+    applyMatchedProperties<LowPriorityProperties>(state, matchResult, applyInheritedOnly);
 
     loadPendingResources(state);
 
     if (!cachedMatchedProperties && cacheHash && MatchedPropertiesCache::isCacheable(element, state.style(), state.parentStyle())) {
         INCREMENT_STYLE_STATS_COUNTER(*this, matchedPropertyCacheAdded);
         m_matchedPropertiesCache.add(state.style(), state.parentStyle(), cacheHash, matchResult);
     }
 
     ASSERT(!state.fontBuilder().fontDirty());
 }
@@ skipping 50 matching lines @@
                 break;
             default:
                 break;
             }
             StyleBuilder::applyProperty(properties[i].property, state, properties[i].value);
         }
     }
 }
 
 } // namespace blink