Style resolution: Apply animation properties earlier in a separate pass

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 1122 matching lines @@
     StyleResolverState& state = m_state;
     ASSERT(!state.style());
 
     // Create the style
     state.setStyle(RenderStyle::clone(elementStyle));
     state.setLineHeightValue(0);
 
     // 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.
     bool inheritedOnly = false;
-    if (keyframe->properties())
+    if (keyframe->properties()) {
+        // FIXME: Can't keyframes contain variables?
+        applyMatchedProperties<AnimationProperties>(result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
         applyMatchedProperties<HighPriorityProperties>(result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
+    }
 
     // If our font got dirtied, go ahead and update it now.
     updateFont();
 
     // Line-height is set when we are sure we decided on the font-size
     if (state.lineHeightValue())
         applyProperty(CSSPropertyLineHeight, state.lineHeightValue());
 
     // Now do rest of the properties.
     if (keyframe->properties())
@@ skipping 627 matching lines @@
 }
 
 Length StyleResolver::convertToFloatLength(CSSPrimitiveValue* primitiveValue, RenderStyle* style, RenderStyle* rootStyle, double multiplier)
 {
     return primitiveValue ? primitiveValue->convertToLength<FixedFloatConversion | PercentConversion | CalculatedConversion | FractionConversion | ViewportPercentageConversion>(style, rootStyle, multiplier) : Length(Undefined);
 }
 
 template <StyleResolver::StyleApplicationPass pass>
 void StyleResolver::applyAnimatedProperties(const Element* target)
 {
+    ASSERT(pass != VariableDefinitions);
+    ASSERT(pass != AnimationProperties);
     if (!target->hasActiveAnimations())
         return;
 
     Vector<Animation*>* animations = target->activeAnimations();
 
     for (size_t i = 0; i < animations->size(); ++i) {
         RefPtr<Animation> animation = animations->at(i);
         const AnimationEffect::CompositableValueMap* compositableValues = animation->compositableValues();
         for (AnimationEffect::CompositableValueMap::const_iterator iter = compositableValues->begin(); iter != compositableValues->end(); ++iter) {
             CSSPropertyID property = iter->key;
-            switch (pass) {
-            case VariableDefinitions:
-                ASSERT_NOT_REACHED();
+            if (!isPropertyForPass<pass>(property))
                 continue;
-            case HighPriorityProperties:
-                if (property > CSSPropertyLineHeight)
-                    continue;
-                break;
-            case LowPriorityProperties:
-                if (property <= CSSPropertyLineHeight)
-                    continue;
-                break;
-            }
-            // FIXME: Composite onto the underlying value.
             RefPtr<CSSValue> value = iter->value->compositeOnto(AnimatableValue::neutralValue())->toCSSValue();
-            if (property == CSSPropertyLineHeight)
+            if (pass == HighPriorityProperties && property == CSSPropertyLineHeight)
                 m_state.setLineHeightValue(value.get());
             else
                 applyProperty(property, value.get());
         }
     }
 }
 
 static inline bool isValidVisitedLinkProperty(CSSPropertyID id)
 {
     switch (id) {
@@ skipping 70 matching lines @@
     case CSSPropertyTextShadow:
     case CSSPropertyBorderStyle:
         return true;
     default:
         break;
     }
     return false;
 }
 
 template <StyleResolver::StyleApplicationPass pass>
+bool StyleResolver::isPropertyForPass(CSSPropertyID property)
+{
+    COMPILE_ASSERT(CSSPropertyVariable < firstCSSProperty, CSS_variable_is_before_first_property);
+    const CSSPropertyID firstAnimationProperty = CSSPropertyWebkitAnimation;
+    const CSSPropertyID lastAnimationProperty = CSSPropertyTransitionTimingFunction;
+    COMPILE_ASSERT(firstCSSProperty == firstAnimationProperty, CSS_first_animation_property_should_be_first_property);
+    const CSSPropertyID firstHighPriorityProperty = CSSPropertyColor;
+    const CSSPropertyID lastHighPriorityProperty = CSSPropertyLineHeight;
+    COMPILE_ASSERT(lastAnimationProperty + 1 == firstHighPriorityProperty, CSS_color_is_first_high_priority_property);
+    COMPILE_ASSERT(CSSPropertyLineHeight == firstHighPriorityProperty + 18, CSS_line_height_is_end_of_high_prioity_property_range);
+    COMPILE_ASSERT(CSSPropertyZoom == lastHighPriorityProperty - 1, CSS_zoom_is_before_line_height);
+    switch (pass) {
+    case VariableDefinitions:
+        return property == CSSPropertyVariable;
+    case AnimationProperties:
+        return property >= firstAnimationProperty && property <= lastAnimationProperty;
+    case HighPriorityProperties:
+        return property >= firstHighPriorityProperty && property <= lastHighPriorityProperty;
+    case LowPriorityProperties:
+        return property > lastHighPriorityProperty;
+    }
+    ASSERT_NOT_REACHED();
+    return false;
+}
+
+template <StyleResolver::StyleApplicationPass pass>
 void StyleResolver::applyProperties(const StylePropertySet* properties, StyleRule* rule, bool isImportant, bool inheritedOnly, PropertyWhitelistType propertyWhitelistType)
 {
     ASSERT((propertyWhitelistType != PropertyWhitelistRegion) || m_state.regionForStyling());
     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willProcessRule(document(), rule, this);
 
     unsigned propertyCount = properties->propertyCount();
     for (unsigned i = 0; i < propertyCount; ++i) {
         StylePropertySet::PropertyReference current = properties->propertyAt(i);
         if (isImportant != current.isImportant())
             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;
         }
         CSSPropertyID property = current.id();
 
         if (propertyWhitelistType == PropertyWhitelistRegion && !isValidRegionStyleProperty(property))
             continue;
         if (propertyWhitelistType == PropertyWhitelistCue && !isValidCueStyleProperty(property))
             continue;
-        switch (pass) {
-        case VariableDefinitions:
-            COMPILE_ASSERT(CSSPropertyVariable < firstCSSProperty, CSS_variable_is_before_first_property);
-            if (property == CSSPropertyVariable)
-                applyProperty(current.id(), current.value());
-            break;
-        case HighPriorityProperties:
-            COMPILE_ASSERT(firstCSSProperty == CSSPropertyColor, CSS_color_is_first_property);
-            COMPILE_ASSERT(CSSPropertyZoom == CSSPropertyColor + 17, CSS_zoom_is_end_of_first_prop_range);
-            COMPILE_ASSERT(CSSPropertyLineHeight == CSSPropertyZoom + 1, CSS_line_height_is_after_zoom);
-            if (property == CSSPropertyVariable)
-                continue;
-            // give special priority to font-xxx, color properties, etc
-            if (property < CSSPropertyLineHeight)
-                applyProperty(current.id(), current.value());
-            // we apply line-height later
-            else if (property == CSSPropertyLineHeight)
-                m_state.setLineHeightValue(current.value());
-            break;
-        case LowPriorityProperties:
-            if (property > CSSPropertyLineHeight)
-                applyProperty(current.id(), current.value());
-        }
+        if (!isPropertyForPass<pass>(property))
+            continue;
+        if (pass == HighPriorityProperties && property == CSSPropertyLineHeight)
+            m_state.setLineHeightValue(current.value());
+        else
+            applyProperty(current.id(), current.value());
     }
     InspectorInstrumentation::didProcessRule(cookie);
 }
 
 template <StyleResolver::StyleApplicationPass pass>
 void StyleResolver::applyMatchedProperties(const MatchResult& matchResult, bool isImportant, int startIndex, int endIndex, bool inheritedOnly)
 {
     if (startIndex == -1)
         return;
 
@@ skipping 77 matching lines @@
         }
         applyInheritedOnly = true;
     }
 
     // First apply all variable definitions, as they may be used during application of later properties.
     applyMatchedProperties<VariableDefinitions>(matchResult, false, 0, matchResult.matchedProperties.size() - 1, applyInheritedOnly);
     applyMatchedProperties<VariableDefinitions>(matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule, applyInheritedOnly);
     applyMatchedProperties<VariableDefinitions>(matchResult, true, matchResult.ranges.firstUserRule, matchResult.ranges.lastUserRule, applyInheritedOnly);
     applyMatchedProperties<VariableDefinitions>(matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
 
+    // Apply animation properties in order to apply animation results and trigger transitions below.
+    applyMatchedProperties<AnimationProperties>(matchResult, false, 0, matchResult.matchedProperties.size() - 1, applyInheritedOnly);
+    applyMatchedProperties<AnimationProperties>(matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule, applyInheritedOnly);
+    applyMatchedProperties<AnimationProperties>(matchResult, true, matchResult.ranges.firstUserRule, matchResult.ranges.lastUserRule, applyInheritedOnly);
+    applyMatchedProperties<AnimationProperties>(matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
+    // FIXME: animations should be triggered here
+
     // 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>(matchResult, false, 0, matchResult.matchedProperties.size() - 1, applyInheritedOnly);
     // Animation contributions are processed here because CSS Animations are overridable by user !important rules.
     if (RuntimeEnabledFeatures::webAnimationsEnabled())
         applyAnimatedProperties<HighPriorityProperties>(element);
     applyMatchedProperties<HighPriorityProperties>(matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule, applyInheritedOnly);
@@ skipping 1386 matching lines @@
 void CachedMatchedProperties::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
     MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::CSS);
     info.addMember(matchedProperties, "matchedProperties");
     info.addMember(ranges, "ranges");
     info.addMember(renderStyle, "renderStyle");
     info.addMember(parentRenderStyle, "parentRenderStyle");
 }
 
 } // namespace WebCore