Cascade declared property values instead of applying values on top of each other

Source/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 13 matching lines @@
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "config.h"
 #include "core/css/resolver/StyleResolver.h"
 
 #include "core/CSSPropertyNames.h"
 #include "core/HTMLNames.h"
-#include "core/StylePropertyShorthand.h"
 #include "core/animation/ActiveAnimations.h"
 #include "core/animation/Animation.h"
 #include "core/animation/AnimationTimeline.h"
 #include "core/animation/animatable/AnimatableValue.h"
 #include "core/animation/css/CSSAnimatableValueFactory.h"
 #include "core/animation/css/CSSAnimations.h"
 #include "core/animation/interpolation/StyleInterpolation.h"
 #include "core/css/CSSCalculationValue.h"
 #include "core/css/CSSDefaultStyleSheets.h"
 #include "core/css/CSSFontSelector.h"
 #include "core/css/CSSKeyframeRule.h"
 #include "core/css/CSSKeyframesRule.h"
 #include "core/css/CSSReflectValue.h"
 #include "core/css/CSSRuleList.h"
 #include "core/css/CSSSelector.h"
 #include "core/css/CSSStyleRule.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/ElementRuleCollector.h"
 #include "core/css/FontFace.h"
 #include "core/css/MediaQueryEvaluator.h"
 #include "core/css/PageRuleCollector.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRuleImport.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/parser/BisonCSSParser.h"
 #include "core/css/resolver/AnimatedStyleBuilder.h"
+#include "core/css/resolver/CascadedValues.h"
 #include "core/css/resolver/MatchResult.h"
 #include "core/css/resolver/MediaQueryResult.h"
 #include "core/css/resolver/SharedStyleFinder.h"
 #include "core/css/resolver/StyleAdjuster.h"
 #include "core/css/resolver/StyleResolverParentScope.h"
 #include "core/css/resolver/StyleResolverState.h"
 #include "core/css/resolver/StyleResolverStats.h"
 #include "core/css/resolver/ViewportStyleResolver.h"
 #include "core/dom/CSSSelectorWatch.h"
 #include "core/dom/NodeRenderStyle.h"
@@ skipping 18 matching lines @@
 using namespace blink;
 
 void setAnimationUpdateIfNeeded(StyleResolverState& state, Element& element)
 {
     // If any changes to CSS Animations were detected, stash the update away for application after the
     // render object is updated if we're in the appropriate scope.
     if (state.animationUpdate())
         element.ensureActiveAnimations().cssAnimations().setPendingUpdate(state.takeAnimationUpdate());
 }
 
+static bool elementTypeHasAppearanceFromUAStyle(const Element& element)
+{
+    // These elements have -webkit-appearance specified in html.css

[esprehn, 2014/07/21 18:50:34]

What happens if someone uses webkit-appearance not in a UA style or this gets
out of sync?

[Timothy Loh, 2014/07/22 14:32:48]

It isn't of concern here whether -webkit-appearance is specified as an author
rule. cacheUserAgentBorderAndBackground currently only does anything if the UA
style has -webkit-appearance set (I'm just trying to match existing behaviour
right now). Note that a subsequent patch (wip at
https://codereview.chromium.org/361173002/) will make some clean-ups to handling
-webkit-appearance.

I couldn't find any nice points to add an assertion that this check matches
what's in the current UA stylesheet.

+    const AtomicString& localName = element.localName();
+    return localName == HTMLNames::inputTag
+        || localName == HTMLNames::textareaTag
+        || localName == HTMLNames::buttonTag
+        || localName == HTMLNames::progressTag
+        || localName == HTMLNames::selectTag
+        || localName == HTMLNames::meterTag;
+}
+
 } // namespace
 
 namespace blink {
 
 using namespace HTMLNames;
 
 RenderStyle* StyleResolver::s_styleNotYetAvailable;
 
 static StylePropertySet* leftToRightDeclaration()
 {
@@ skipping 574 matching lines @@
 
     setAnimationUpdateIfNeeded(state, *element);
 
     if (state.style()->hasViewportUnits())
         document().setHasViewportUnits();
 
     // Now return the style.
     return state.takeStyle();
 }
 
+// FIXME: Consider refactoring to create a new class which owns the following
+// first/last/range properties.
+// c.f. //src/third_party/WebKit/Source/core/css/CSSPropertyNames.in.
+
+template<> CSSPropertyID StyleResolver::firstCSSPropertyId<StyleResolver::HighPriorityProperties>()
+{
+    COMPILE_ASSERT(CSSPropertyColor == CSSPropertyWebkitWritingMode + 1, CSS_color_is_first_high_priority_property);
+    return CSSPropertyColor;
+}
+
+template<> CSSPropertyID StyleResolver::lastCSSPropertyId<StyleResolver::HighPriorityProperties>()
+{
+    return CSSPropertyZoom;
+}
+
+template<> CSSPropertyID StyleResolver::firstCSSPropertyId<StyleResolver::LowPriorityProperties>()
+{
+    COMPILE_ASSERT(CSSPropertyBackground == CSSPropertyZoom + 1, CSS_background_is_first_low_priority_property);
+    return CSSPropertyBackground;
+}
+
+template<> CSSPropertyID StyleResolver::lastCSSPropertyId<StyleResolver::LowPriorityProperties>()
+{
+    return convertToCSSPropertyID(lastCSSProperty);
+}
+
+template <StyleResolver::StyleApplicationPass pass>
+bool StyleResolver::isPropertyForPass(CSSPropertyID property)
+{
+    return firstCSSPropertyId<pass>() <= property && property <= lastCSSPropertyId<pass>();
+}
+
 PassRefPtr<RenderStyle> StyleResolver::styleForKeyframe(Element* element, const RenderStyle& elementStyle, RenderStyle* parentStyle, const StyleKeyframe* keyframe, const AtomicString& animationName)
 {
     ASSERT(document().frame());
     ASSERT(document().settings());
     ASSERT(!hasPendingAuthorStyleSheets());
 
     if (element == document().documentElement())
         resetDirectionAndWritingModeOnDocument(document());
     StyleResolverState state(document(), element, parentStyle);
 
-    MatchResult result;
-    result.addMatchedProperties(&keyframe->properties());
+    MatchResult matchResult;
+    matchResult.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, 0, result.matchedProperties.size() - 1, inheritedOnly);
+    CascadedValues cascadedValues(state, matchResult);
+    cascadedValues.addMatchResult(matchResult, false, 0, matchResult.matchedProperties.size() - 1);
+
+    cascadedValues.applyValues(firstCSSPropertyId<HighPriorityProperties>(), lastCSSPropertyId<HighPriorityProperties>());
 
     // 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, 0, result.matchedProperties.size() - 1, inheritedOnly);
+    cascadedValues.applyValues(firstCSSPropertyId<LowPriorityProperties>(), lastCSSPropertyId<LowPriorityProperties>());
 
     // If our font got dirtied by one of the non-essential font props,
     // go ahead and update it a second time.
     updateFont(state);
 
     loadPendingResources(state);
 
     didAccess();
 
     return state.takeStyle();
@@ skipping 147 matching lines @@
 
     state.fontBuilder().initForStyleResolve(state.document(), state.style());
 
     PageRuleCollector collector(rootElementStyle, pageIndex);
 
     collector.matchPageRules(CSSDefaultStyleSheets::instance().defaultPrintStyle());
 
     if (ScopedStyleResolver* scopedResolver = m_styleTree.scopedStyleResolverForDocument())
         scopedResolver->matchPageRules(collector);
 
-    state.setLineHeightValue(0);
-    bool inheritedOnly = false;
+    MatchResult& matchResult = collector.matchedResult();
+    CascadedValues cascadedValues(state, matchResult);
+    cascadedValues.addMatchResult(matchResult, false, 0, matchResult.matchedProperties.size() - 1);
+    cascadedValues.addMatchResult(matchResult, true, 0, matchResult.matchedProperties.size() - 1);
 
-    MatchResult& result = collector.matchedResult();
-    applyMatchedProperties<HighPriorityProperties>(state, result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
+    cascadedValues.applyValues(firstCSSPropertyId<HighPriorityProperties>(), lastCSSPropertyId<HighPriorityProperties>());
 
     // 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());
-
-    applyMatchedProperties<LowPriorityProperties>(state, result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
+    cascadedValues.applyValues(firstCSSPropertyId<LowPriorityProperties>(), lastCSSPropertyId<LowPriorityProperties>());
 
     addContentAttrValuesToFeatures(state.contentAttrValues(), m_features);
 
     loadPendingResources(state);
 
     didAccess();
 
     // Now return the style.
     return state.takeStyle();
 }
@@ skipping 14 matching lines @@
 
     viewportStyleResolver()->resolve();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::defaultStyleForElement()
 {
     StyleResolverState state(document(), 0);
     state.setStyle(RenderStyle::create());
     state.fontBuilder().initForStyleResolve(document(), state.style());
     state.style()->setLineHeight(RenderStyle::initialLineHeight());
-    state.setLineHeightValue(0);
     state.fontBuilder().setInitial(state.style()->effectiveZoom());
     state.style()->font().update(document().styleEngine()->fontSelector());
     return state.takeStyle();
 }
 
 PassRefPtr<RenderStyle> StyleResolver::styleForText(Text* textNode)
 {
     ASSERT(textNode);
 
     NodeRenderingTraversal::ParentDetails parentDetails;
@@ skipping 64 matching lines @@
     if (!(animatingElement && animatingElement->hasActiveAnimations())
         && !state.style()->transitions() && !state.style()->animations())
         return false;
 
     state.setAnimationUpdate(CSSAnimations::calculateUpdate(animatingElement, *element, *state.style(), state.parentStyle(), this));
     if (!state.animationUpdate())
         return false;
 
     const WillBeHeapHashMap<CSSPropertyID, RefPtrWillBeMember<Interpolation> >& activeInterpolationsForAnimations = state.animationUpdate()->activeInterpolationsForAnimations();
     const WillBeHeapHashMap<CSSPropertyID, RefPtrWillBeMember<Interpolation> >& activeInterpolationsForTransitions = state.animationUpdate()->activeInterpolationsForTransitions();
+
+    // FIXME: Is it possible to use CascadedValues here or is it too expensive to
+    // convert from Interpolations to CSSValues?
     applyAnimatedProperties<HighPriorityProperties>(state, activeInterpolationsForAnimations);
     applyAnimatedProperties<HighPriorityProperties>(state, activeInterpolationsForTransitions);
 
     updateFont(state);
 
     applyAnimatedProperties<LowPriorityProperties>(state, activeInterpolationsForAnimations);
     applyAnimatedProperties<LowPriorityProperties>(state, activeInterpolationsForTransitions);
 
     // Start loading resources used by animations.
     loadPendingResources(state);
 
     ASSERT(!state.fontBuilder().fontDirty());
 
     return true;
 }
 
 template <StyleResolver::StyleApplicationPass pass>
 void StyleResolver::applyAnimatedProperties(StyleResolverState& state, const WillBeHeapHashMap<CSSPropertyID, RefPtrWillBeMember<Interpolation> >& activeInterpolations)
 {
     for (WillBeHeapHashMap<CSSPropertyID, RefPtrWillBeMember<Interpolation> >::const_iterator iter = activeInterpolations.begin(); iter != activeInterpolations.end(); ++iter) {
         CSSPropertyID property = iter->key;
         if (!isPropertyForPass<pass>(property))
             continue;
         const StyleInterpolation* interpolation = toStyleInterpolation(iter->value.get());
         interpolation->apply(state);
     }
 }
 
-static inline bool isValidCueStyleProperty(CSSPropertyID id)
-{
-    switch (id) {
-    case CSSPropertyBackground:
-    case CSSPropertyBackgroundAttachment:
-    case CSSPropertyBackgroundClip:
-    case CSSPropertyBackgroundColor:
-    case CSSPropertyBackgroundImage:
-    case CSSPropertyBackgroundOrigin:
-    case CSSPropertyBackgroundPosition:
-    case CSSPropertyBackgroundPositionX:
-    case CSSPropertyBackgroundPositionY:
-    case CSSPropertyBackgroundRepeat:
-    case CSSPropertyBackgroundRepeatX:
-    case CSSPropertyBackgroundRepeatY:
-    case CSSPropertyBackgroundSize:
-    case CSSPropertyColor:
-    case CSSPropertyFont:
-    case CSSPropertyFontFamily:
-    case CSSPropertyFontSize:
-    case CSSPropertyFontStyle:
-    case CSSPropertyFontVariant:
-    case CSSPropertyFontWeight:
-    case CSSPropertyLineHeight:
-    case CSSPropertyOpacity:
-    case CSSPropertyOutline:
-    case CSSPropertyOutlineColor:
-    case CSSPropertyOutlineOffset:
-    case CSSPropertyOutlineStyle:
-    case CSSPropertyOutlineWidth:
-    case CSSPropertyVisibility:
-    case CSSPropertyWhiteSpace:
-    // FIXME: 'text-decoration' shorthand to be handled when available.
-    // See https://chromiumcodereview.appspot.com/19516002 for details.
-    case CSSPropertyTextDecoration:
-    case CSSPropertyTextShadow:
-    case CSSPropertyBorderStyle:
-        return true;
-    case CSSPropertyTextDecorationLine:
-    case CSSPropertyTextDecorationStyle:
-    case CSSPropertyTextDecorationColor:
-        return RuntimeEnabledFeatures::css3TextDecorationsEnabled();
-    default:
-        break;
-    }
-    return false;
-}
-
-static inline bool isValidFirstLetterStyleProperty(CSSPropertyID id)
-{
-    switch (id) {
-    // Valid ::first-letter properties listed in spec:
-    // http://www.w3.org/TR/css3-selectors/#application-in-css
-    case CSSPropertyBackgroundAttachment:
-    case CSSPropertyBackgroundBlendMode:
-    case CSSPropertyBackgroundClip:
-    case CSSPropertyBackgroundColor:
-    case CSSPropertyBackgroundImage:
-    case CSSPropertyBackgroundOrigin:
-    case CSSPropertyBackgroundPosition:
-    case CSSPropertyBackgroundPositionX:
-    case CSSPropertyBackgroundPositionY:
-    case CSSPropertyBackgroundRepeat:
-    case CSSPropertyBackgroundRepeatX:
-    case CSSPropertyBackgroundRepeatY:
-    case CSSPropertyBackgroundSize:
-    case CSSPropertyBorderBottomColor:
-    case CSSPropertyBorderBottomLeftRadius:
-    case CSSPropertyBorderBottomRightRadius:
-    case CSSPropertyBorderBottomStyle:
-    case CSSPropertyBorderBottomWidth:
-    case CSSPropertyBorderImageOutset:
-    case CSSPropertyBorderImageRepeat:
-    case CSSPropertyBorderImageSlice:
-    case CSSPropertyBorderImageSource:
-    case CSSPropertyBorderImageWidth:
-    case CSSPropertyBorderLeftColor:
-    case CSSPropertyBorderLeftStyle:
-    case CSSPropertyBorderLeftWidth:
-    case CSSPropertyBorderRightColor:
-    case CSSPropertyBorderRightStyle:
-    case CSSPropertyBorderRightWidth:
-    case CSSPropertyBorderTopColor:
-    case CSSPropertyBorderTopLeftRadius:
-    case CSSPropertyBorderTopRightRadius:
-    case CSSPropertyBorderTopStyle:
-    case CSSPropertyBorderTopWidth:
-    case CSSPropertyColor:
-    case CSSPropertyFloat:
-    case CSSPropertyFont:
-    case CSSPropertyFontFamily:
-    case CSSPropertyFontKerning:
-    case CSSPropertyFontSize:
-    case CSSPropertyFontStretch:
-    case CSSPropertyFontStyle:
-    case CSSPropertyFontVariant:
-    case CSSPropertyFontVariantLigatures:
-    case CSSPropertyFontWeight:
-    case CSSPropertyLetterSpacing:
-    case CSSPropertyLineHeight:
-    case CSSPropertyMarginBottom:
-    case CSSPropertyMarginLeft:
-    case CSSPropertyMarginRight:
-    case CSSPropertyMarginTop:
-    case CSSPropertyPaddingBottom:
-    case CSSPropertyPaddingLeft:
-    case CSSPropertyPaddingRight:
-    case CSSPropertyPaddingTop:
-    case CSSPropertyTextTransform:
-    case CSSPropertyVerticalAlign:
-    case CSSPropertyWebkitBackgroundClip:
-    case CSSPropertyWebkitBackgroundComposite:
-    case CSSPropertyWebkitBackgroundOrigin:
-    case CSSPropertyWebkitBackgroundSize:
-    case CSSPropertyWebkitBorderAfter:
-    case CSSPropertyWebkitBorderAfterColor:
-    case CSSPropertyWebkitBorderAfterStyle:
-    case CSSPropertyWebkitBorderAfterWidth:
-    case CSSPropertyWebkitBorderBefore:
-    case CSSPropertyWebkitBorderBeforeColor:
-    case CSSPropertyWebkitBorderBeforeStyle:
-    case CSSPropertyWebkitBorderBeforeWidth:
-    case CSSPropertyWebkitBorderEnd:
-    case CSSPropertyWebkitBorderEndColor:
-    case CSSPropertyWebkitBorderEndStyle:
-    case CSSPropertyWebkitBorderEndWidth:
-    case CSSPropertyWebkitBorderFit:
-    case CSSPropertyWebkitBorderHorizontalSpacing:
-    case CSSPropertyWebkitBorderImage:
-    case CSSPropertyWebkitBorderRadius:
-    case CSSPropertyWebkitBorderStart:
-    case CSSPropertyWebkitBorderStartColor:
-    case CSSPropertyWebkitBorderStartStyle:
-    case CSSPropertyWebkitBorderStartWidth:
-    case CSSPropertyWebkitBorderVerticalSpacing:
-    case CSSPropertyWebkitFontSmoothing:
-    case CSSPropertyWebkitMarginAfter:
-    case CSSPropertyWebkitMarginAfterCollapse:
-    case CSSPropertyWebkitMarginBefore:
-    case CSSPropertyWebkitMarginBeforeCollapse:
-    case CSSPropertyWebkitMarginBottomCollapse:
-    case CSSPropertyWebkitMarginCollapse:
-    case CSSPropertyWebkitMarginEnd:
-    case CSSPropertyWebkitMarginStart:
-    case CSSPropertyWebkitMarginTopCollapse:
-    case CSSPropertyWordSpacing:
-        return true;
-    case CSSPropertyTextDecorationColor:
-    case CSSPropertyTextDecorationLine:
-    case CSSPropertyTextDecorationStyle:
-        return RuntimeEnabledFeatures::css3TextDecorationsEnabled();
-
-    // text-shadow added in text decoration spec:
-    // http://www.w3.org/TR/css-text-decor-3/#text-shadow-property
-    case CSSPropertyTextShadow:
-    // box-shadox added in CSS3 backgrounds spec:
-    // http://www.w3.org/TR/css3-background/#placement
-    case CSSPropertyBoxShadow:
-    case CSSPropertyWebkitBoxShadow:
-    // Properties that we currently support outside of spec.
-    case CSSPropertyWebkitLineBoxContain:
-    case CSSPropertyVisibility:
-        return true;
-
-    default:
-        return false;
-    }
-}
-
-// FIXME: Consider refactoring to create a new class which owns the following
-// first/last/range properties.
-// This method returns the first CSSPropertyId of high priority properties.
-// Other properties can depend on high priority properties. For example,
-// border-color property with currentColor value depends on color property.
-// All high priority properties are obtained by using
-// firstCSSPropertyId<HighPriorityProperties> and
-// lastCSSPropertyId<HighPriorityProperties>.
-template<> CSSPropertyID StyleResolver::firstCSSPropertyId<StyleResolver::HighPriorityProperties>()
-{
-    COMPILE_ASSERT(CSSPropertyColor == firstCSSProperty, CSS_color_is_first_high_priority_property);
-    return CSSPropertyColor;
-}
-
-// This method returns the last CSSPropertyId of high priority properties.
-template<> CSSPropertyID StyleResolver::lastCSSPropertyId<StyleResolver::HighPriorityProperties>()
-{
-    COMPILE_ASSERT(CSSPropertyLineHeight == CSSPropertyColor + 17, CSS_line_height_is_end_of_high_prioity_property_range);
-    COMPILE_ASSERT(CSSPropertyZoom == CSSPropertyLineHeight - 1, CSS_zoom_is_before_line_height);
-    return CSSPropertyLineHeight;
-}
-
-// This method returns the first CSSPropertyId of remaining properties,
-// i.e. low priority properties. No properties depend on low priority
-// properties. So we don't need to resolve such properties quickly.
-// All low priority properties are obtained by using
-// firstCSSPropertyId<LowPriorityProperties> and
-// lastCSSPropertyId<LowPriorityProperties>.
-template<> CSSPropertyID StyleResolver::firstCSSPropertyId<StyleResolver::LowPriorityProperties>()
-{
-    COMPILE_ASSERT(CSSPropertyBackground == CSSPropertyLineHeight + 1, CSS_background_is_first_low_priority_property);
-    return CSSPropertyBackground;
-}
-
-// This method returns the last CSSPropertyId of low priority properties.
-template<> CSSPropertyID StyleResolver::lastCSSPropertyId<StyleResolver::LowPriorityProperties>()
-{
-    return static_cast<CSSPropertyID>(lastCSSProperty);
-}
-
-template <StyleResolver::StyleApplicationPass pass>
-bool StyleResolver::isPropertyForPass(CSSPropertyID property)
-{
-    return firstCSSPropertyId<pass>() <= property && property <= lastCSSPropertyId<pass>();
-}
-
-// This method expands the 'all' shorthand property to longhand properties
-// and applies the expanded longhand properties.
-template <StyleResolver::StyleApplicationPass pass>
-void StyleResolver::applyAllProperty(StyleResolverState& state, CSSValue* allValue)
-{
-    bool isUnsetValue = !allValue->isInitialValue() && !allValue->isInheritedValue();
-    unsigned startCSSProperty = firstCSSPropertyId<pass>();
-    unsigned endCSSProperty = lastCSSPropertyId<pass>();
-
-    for (unsigned i = startCSSProperty; i <= endCSSProperty; ++i) {
-        CSSPropertyID propertyId = static_cast<CSSPropertyID>(i);
-
-        // StyleBuilder does not allow any expanded shorthands.
-        if (isExpandedShorthandForAll(propertyId))
-            continue;
-
-        // all shorthand spec says:
-        // The all property is a shorthand that resets all CSS properties
-        // except direction and unicode-bidi.
-        // c.f. http://dev.w3.org/csswg/css-cascade/#all-shorthand
-        // We skip applyProperty when a given property is unicode-bidi or
-        // direction.
-        if (!CSSProperty::isAffectedByAllProperty(propertyId))
-            continue;
-
-        CSSValue* value;
-        if (!isUnsetValue) {
-            value = allValue;
-        } else {
-            if (CSSProperty::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, StyleRule* rule, bool isImportant, bool inheritedOnly, PropertyWhitelistType propertyWhitelistType)
-{
-    state.setCurrentRule(rule);
-
-    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 (propertyWhitelistType == PropertyWhitelistCue && !isValidCueStyleProperty(property))
-            continue;
-        if (propertyWhitelistType == PropertyWhitelistFirstLetter && !isValidFirstLetterStyleProperty(property))
-            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, int startIndex, int endIndex, bool inheritedOnly)
-{
-    if (startIndex == -1)
-        return;
-
-    if (state.style()->insideLink() != NotInsideLink) {
-        for (int i = startIndex; i <= endIndex; ++i) {
-            const MatchedProperties& matchedProperties = matchResult.matchedProperties[i];
-            unsigned linkMatchType = matchedProperties.m_types.linkMatchType;
-            // FIXME: It would be nicer to pass these as arguments but that requires changes in many places.
-            state.setApplyPropertyToRegularStyle(linkMatchType & SelectorChecker::MatchLink);
-            state.setApplyPropertyToVisitedLinkStyle(linkMatchType & SelectorChecker::MatchVisited);
-
-            applyProperties<pass>(state, matchedProperties.properties.get(), matchResult.matchedRules[i], isImportant, inheritedOnly, static_cast<PropertyWhitelistType>(matchedProperties.m_types.whitelistType));
-        }
-        state.setApplyPropertyToRegularStyle(true);
-        state.setApplyPropertyToVisitedLinkStyle(false);
-        return;
-    }
-    for (int i = startIndex; i <= endIndex; ++i) {
-        const MatchedProperties& matchedProperties = matchResult.matchedProperties[i];
-        applyProperties<pass>(state, matchedProperties.properties.get(), matchResult.matchedRules[i], isImportant, inheritedOnly, static_cast<PropertyWhitelistType>(matchedProperties.m_types.whitelistType));
-    }
-}
-
 static unsigned computeMatchedPropertiesHash(const MatchedProperties* properties, unsigned size)
 {
     return StringHasher::hashMemory(properties, sizeof(MatchedProperties) * size);
 }
 
 void StyleResolver::invalidateMatchedPropertiesCache()
 {
     m_matchedPropertiesCache.clear();
 }
 
@@ skipping 29 matching lines @@
             // resulting style will be identical too. We copy the inherited properties over from the cache and are done.
             state.style()->inheritFrom(cachedMatchedProperties->renderStyle.get());
 
             // Unfortunately the link status is treated like an inherited property. We need to explicitly restore it.
             state.style()->setInsideLink(linkStatus);
             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, 0, matchResult.matchedProperties.size() - 1, applyInheritedOnly);
-    applyMatchedProperties<HighPriorityProperties>(state, matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule, applyInheritedOnly);
-    applyMatchedProperties<HighPriorityProperties>(state, matchResult, true, matchResult.ranges.firstUserRule, matchResult.ranges.lastUserRule, applyInheritedOnly);
-    applyMatchedProperties<HighPriorityProperties>(state, matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
+    CascadedValues cascadedValues(state, matchResult);
+
+    // The MatchResult has rules in UA - User - Author order, although we only
+    // use user rules for callback selectors.
+    cascadedValues.addMatchResult(matchResult, false, 0, matchResult.matchedProperties.size() - 1);
+    cascadedValues.addMatchResult(matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule);
+    cascadedValues.addMatchResult(matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule);

[esprehn, 2014/07/21 18:50:34]

Can we get rid of this boolean?

[Timothy Loh, 2014/07/22 14:32:48]

See other comment

+
+    cascadedValues.applyValues(firstCSSPropertyId<HighPriorityProperties>(), lastCSSPropertyId<HighPriorityProperties>(), applyInheritedOnly);
 
     if (UNLIKELY(isSVGForeignObjectElement(element))) {
         // RenderSVGRoot handles zooming for the whole SVG subtree, so foreignObject content should not be scaled again.
         //
         // FIXME: The following hijacks the zoom property for foreignObject so that children of foreignObject get the
         // correct font-size in case of zooming. 'zoom' is part of HighPriorityProperties, along with other font-related
         // properties used as input to the FontBuilder, so resetting it here may cause the FontBuilder to recompute the
         // font used as inheritable font for foreignObject content. If we want to support zoom on foreignObject we'll
         // need to find another way of handling the SVG zoom model.
         state.setEffectiveZoom(RenderStyle::initialZoom());
     }
 
     if (cachedMatchedProperties && cachedMatchedProperties->renderStyle->effectiveZoom() != state.style()->effectiveZoom()) {
         state.fontBuilder().setFontDirty(true);
         applyInheritedOnly = false;
     }
 
     // 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 normal priority UA properties.
-    applyMatchedProperties<LowPriorityProperties>(state, matchResult, false, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
+    // This code supports -webkit-appearance, for which we are interested
+    // in whether the user has specified border or background properties.
+    // FIXME: This is a bit of a mess, we should just compare CSSValues and
+    // store a single bit for this.
+    if (elementTypeHasAppearanceFromUAStyle(*element)) {
+        CascadedValues userAgentValues(state, matchResult);
+        userAgentValues.addMatchResult(matchResult, false, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule);
+        // We only actually care about border and background properties here
+        userAgentValues.applyValues(firstCSSPropertyId<LowPriorityProperties>(), lastCSSPropertyId<LowPriorityProperties>(), applyInheritedOnly);
+        state.cacheUserAgentBorderAndBackground();
+    }
 
-    // Cache the UA properties to pass them to RenderTheme in adjustRenderStyle.
-    state.cacheUserAgentBorderAndBackground();
-
-    // Now do the author and user normal priority properties and all the !important properties.
-    applyMatchedProperties<LowPriorityProperties>(state, matchResult, false, matchResult.ranges.lastUARule + 1, matchResult.matchedProperties.size() - 1, applyInheritedOnly);
-    applyMatchedProperties<LowPriorityProperties>(state, matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule, applyInheritedOnly);
-    applyMatchedProperties<LowPriorityProperties>(state, matchResult, true, matchResult.ranges.firstUserRule, matchResult.ranges.lastUserRule, applyInheritedOnly);
-    applyMatchedProperties<LowPriorityProperties>(state, matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
+    cascadedValues.applyValues(firstCSSPropertyId<LowPriorityProperties>(), lastCSSPropertyId<LowPriorityProperties>(), 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 81 matching lines @@
     visitor->trace(m_features);
     visitor->trace(m_siblingRuleSet);
     visitor->trace(m_uncommonAttributeRuleSet);
     visitor->trace(m_watchedSelectorsRules);
     visitor->trace(m_treeBoundaryCrossingRules);
     visitor->trace(m_pendingStyleSheets);
 #endif
 }
 
 } // namespace blink