Skip rule matching during animations.

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 525 matching lines @@
     adjuster.adjustRenderStyle(state.style(), state.parentStyle(), element, state.cachedUAStyle());
 }
 
 // Start loading resources referenced by this style.
 void StyleResolver::loadPendingResources(StyleResolverState& state)
 {
     m_styleResourceLoader.loadPendingResources(state.style(), state.elementStyleResources());
     document().styleEngine()->fontSelector()->fontLoader()->loadPendingFonts();
 }
 
+struct AnimationResolveData {
+
+    AnimationResolveData(Element* element)
+        : baseRenderStyle(nullptr)
+        , useBaseRenderStyle(false)
+    {
+        if (!element)
+            return;
+
+        if (ActiveAnimations* animations = element->activeAnimations()) {
+            useBaseRenderStyle = animations->isAnimationStyleChange();
+            if (useBaseRenderStyle)
+                baseRenderStyle = animations->baseRenderStyle();
+            else
+                animations->setBaseRenderStyle(nullptr);

[esprehn, 2014/10/13 21:44:26]

This really doesn't seem like the right place to have side effects.

[rune, 2014/10/13 22:24:49]

There are a bunch of ways to do this. Do you think ActiveAnimations itself or
StyleResolver should be responsible for clearing the baseRenderStyle pointer?

We could put the logic inside ActiveAnimations and even make
isAnimationsStyleChange() private again:

RenderStyle* ActiveAnimations::baseRenderStyle() const
{
    if (isAnimationStyleChange())
        return m_baseRenderStyle;
    
    return nullptr;
}

void ActiveAnimations::updateBaseRenderStyle(RenderStyle*)
{
    if (isAnimationsStyleChange())
        m_baseRenderStyle = RenderStyle::clone(...);
    else
        m_baseRenderStyle = nullptr;
}


WDYT?

+
+#if ENABLE(ASSERT)
+            // Force recalc of the base style to check that the cached one was correct.
+            baseRenderStyle = nullptr;
+#endif // !ASSERT
+        }
+    }
+
+    const RenderStyle* baseRenderStyle;
+    bool useBaseRenderStyle;
+};
+
 PassRefPtr<RenderStyle> StyleResolver::styleForElement(Element* element, RenderStyle* defaultParent, StyleSharingBehavior sharingBehavior,
     RuleMatchingBehavior matchingBehavior)
 {
     ASSERT(document().frame());
     ASSERT(document().settings());
     ASSERT(!hasPendingAuthorStyleSheets());
     ASSERT(!m_needCollectFeatures);
 
     // Once an element has a renderer, we don't try to destroy it, since otherwise the renderer
     // will vanish if a style recalc happens during loading.
@@ skipping 15 matching lines @@
     if (element == document().documentElement())
         resetDirectionAndWritingModeOnDocument(document());
     StyleResolverState state(document(), element, defaultParent);
 
     if (sharingBehavior == AllowStyleSharing && state.parentStyle()) {
         SharedStyleFinder styleFinder(state.elementContext(), m_features, m_siblingRuleSet.get(), m_uncommonAttributeRuleSet.get(), *this);
         if (RefPtr<RenderStyle> sharedStyle = styleFinder.findSharedStyle())
             return sharedStyle.release();
     }
 
-    if (state.parentStyle()) {
+
+    AnimationResolveData animationData(element);
+
+    if (animationData.baseRenderStyle) {
+        state.setStyle(RenderStyle::clone(animationData.baseRenderStyle));
+    } else if (state.parentStyle()) {
         state.setStyle(RenderStyle::create());
         state.style()->inheritFrom(state.parentStyle(), isAtShadowBoundary(element) ? RenderStyle::AtShadowBoundary : RenderStyle::NotAtShadowBoundary);
     } else {
         state.setStyle(defaultStyleForElement());
         state.setParentStyle(RenderStyle::clone(state.style()));
     }
     // contenteditable attribute (implemented by -webkit-user-modify) should
     // be propagated from shadow host to distributed node.
     if (state.distributedToInsertionPoint()) {
         if (Element* parent = element->parentElement()) {
             if (RenderStyle* styleOfShadowHost = parent->renderStyle())
                 state.style()->setUserModify(styleOfShadowHost->userModify());
         }
     }
 
     state.fontBuilder().initForStyleResolve(state.document(), state.style());
 
     if (element->isLink()) {
         state.style()->setIsLink(true);
         EInsideLink linkState = state.elementLinkState();
         if (linkState != NotInsideLink) {
             bool forceVisited = InspectorInstrumentation::forcePseudoState(element, CSSSelector::PseudoVisited);
             if (forceVisited)
                 linkState = InsideVisitedLink;
         }
         state.style()->setInsideLink(linkState);
     }
 
-    bool needsCollection = false;
-    CSSDefaultStyleSheets::instance().ensureDefaultStyleSheetsForElement(element, needsCollection);
-    if (needsCollection)
-        collectFeatures();
+    if (!animationData.baseRenderStyle) {
 
-    {
+        bool needsCollection = false;
+        CSSDefaultStyleSheets::instance().ensureDefaultStyleSheetsForElement(element, needsCollection);
+        if (needsCollection)
+            collectFeatures();
+
         ElementRuleCollector collector(state.elementContext(), m_selectorFilter, state.style());
 
         matchAllRules(state, collector, matchingBehavior != MatchAllRulesExcludingSMIL);
 
         applyMatchedProperties(state, collector.matchedResult());
         applyCallbackSelectors(state);
 
         addContentAttrValuesToFeatures(state.contentAttrValues(), m_features);
+
+        // Cache our original display.
+        state.style()->setOriginalDisplay(state.style()->display());
+
+        adjustRenderStyle(state, element);
+
+        if (animationData.useBaseRenderStyle)
+            element->activeAnimations()->setBaseRenderStyle(RenderStyle::clone(state.style()));
     }
 
-    // Cache our original display.
-    state.style()->setOriginalDisplay(state.style()->display());
-
-    adjustRenderStyle(state, 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))
         adjustRenderStyle(state, element);
 
     if (isHTMLBodyElement(*element))
         document().textLinkColors().setTextColor(state.style()->color());
 
     setAnimationUpdateIfNeeded(state, *element);
@@ skipping 113 matching lines @@
 }
 
 bool StyleResolver::pseudoStyleForElementInternal(Element& element, const PseudoStyleRequest& pseudoStyleRequest, RenderStyle* parentStyle, StyleResolverState& state)
 {
     ASSERT(document().frame());
     ASSERT(document().settings());
     ASSERT(pseudoStyleRequest.pseudoId != FIRST_LINE_INHERITED);
 
     StyleResolverParentScope::ensureParentStackIsPushed();
 
-    if (pseudoStyleRequest.allowsInheritance(state.parentStyle())) {
+    Element* pseudoElement = element.pseudoElement(pseudoStyleRequest.pseudoId);
+
+    AnimationResolveData animationData(pseudoElement);
+
+    if (animationData.baseRenderStyle) {
+        state.setStyle(RenderStyle::clone(animationData.baseRenderStyle));
+    } else if (pseudoStyleRequest.allowsInheritance(state.parentStyle())) {
         state.setStyle(RenderStyle::create());
         state.style()->inheritFrom(state.parentStyle());
     } else {
         state.setStyle(defaultStyleForElement());
         state.setParentStyle(RenderStyle::clone(state.style()));
     }
 
     state.style()->setStyleType(pseudoStyleRequest.pseudoId);
     state.fontBuilder().initForStyleResolve(state.document(), state.style());
 
     // Since we don't use pseudo-elements in any of our quirk/print
     // user agent rules, don't waste time walking those rules.
 
-    {
+    if (!animationData.baseRenderStyle) {
         // Check UA, user and author rules.
         ElementRuleCollector collector(state.elementContext(), m_selectorFilter, state.style());
         collector.setPseudoStyleRequest(pseudoStyleRequest);
 
         matchUARules(collector);
         matchAuthorRules(state.element(), collector, false);
 
         if (collector.matchedResult().matchedProperties.isEmpty())
             return false;
 
         applyMatchedProperties(state, collector.matchedResult());
         applyCallbackSelectors(state);
 
         addContentAttrValuesToFeatures(state.contentAttrValues(), m_features);
+
+        // Cache our original display.
+        state.style()->setOriginalDisplay(state.style()->display());
+
+        // FIXME: Passing 0 as the Element* introduces a lot of complexity
+        // in the adjustRenderStyle code.
+        adjustRenderStyle(state, 0);
+
+        if (animationData.useBaseRenderStyle)
+            pseudoElement->activeAnimations()->setBaseRenderStyle(RenderStyle::clone(state.style()));
     }
 
-    // Cache our original display.
-    state.style()->setOriginalDisplay(state.style()->display());
-
-    // FIXME: Passing 0 as the Element* introduces a lot of complexity
-    // in the adjustRenderStyle code.
-    adjustRenderStyle(state, 0);
-
     // 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.pseudoElement(pseudoStyleRequest.pseudoId)))
+    if (applyAnimatedProperties(state, pseudoElement))
         adjustRenderStyle(state, 0);
 
     didAccess();
 
     if (state.style()->hasViewportUnits())
         document().setHasViewportUnits();
 
     return true;
 }
 
@@ skipping 766 matching lines @@
     visitor->trace(m_uncommonAttributeRuleSet);
     visitor->trace(m_watchedSelectorsRules);
     visitor->trace(m_treeBoundaryCrossingRules);
     visitor->trace(m_styleSharingLists);
     visitor->trace(m_pendingStyleSheets);
     visitor->trace(m_document);
 #endif
 }
 
 } // namespace blink