Merge r174804 - Leverage the new RenderElement::m_isCSSAnimating flag…

… in more places

https://bugs.webkit.org/show_bug.cgi?id=137786

Reviewed by Simon Fraser.

Leverage the new RenderElement::m_isCSSAnimating flag that was introduced
in r174703 in more places, for performance. This avoids doing extra work
for renderers on which we are not running animations on. This patch also
updates the API a bit to use more references instead of pointers, making
it clear the RenderElement cannot be null and thus avoiding unnecessary
null checks.

No new tests, no behavior change.

* css/CSSComputedStyleDeclaration.cpp:
(WebCore::computeRenderStyleForProperty):
* page/animation/AnimationController.cpp:
(WebCore::AnimationControllerPrivate::ensureCompositeAnimation):
(WebCore::AnimationControllerPrivate::clear):
(WebCore::AnimationControllerPrivate::updateAnimationTimerForRenderer):
(WebCore::AnimationControllerPrivate::isRunningAnimationOnRenderer):
(WebCore::AnimationControllerPrivate::isRunningAcceleratedAnimationOnRenderer):
(WebCore::AnimationControllerPrivate::pauseAnimationAtTime):
(WebCore::AnimationControllerPrivate::pauseTransitionAtTime):
(WebCore::AnimationControllerPrivate::getAnimatedStyleForRenderer):
(WebCore::AnimationController::cancelAnimations):
(WebCore::AnimationController::updateAnimations):
(WebCore::AnimationController::getAnimatedStyleForRenderer):
(WebCore::AnimationController::notifyAnimationStarted):
(WebCore::AnimationController::isRunningAnimationOnRenderer):
(WebCore::AnimationController::isRunningAcceleratedAnimationOnRenderer):
* page/animation/AnimationController.h:
* page/animation/AnimationControllerPrivate.h:
* rendering/RenderElement.cpp:
(WebCore::RenderElement::willBeDestroyed):
* rendering/RenderLayer.cpp:
(WebCore::RenderLayer::currentTransform):
* rendering/RenderLayerBacking.cpp:
(WebCore::RenderLayerBacking::updateGeometry):
(WebCore::RenderLayerBacking::notifyAnimationStarted):
* rendering/RenderLayerCompositor.cpp:
(WebCore::RenderLayerCompositor::requiresCompositingForAnimation):
(WebCore::RenderLayerCompositor::isRunningAcceleratedTransformAnimation):

Canonical link: https://commits.webkit.org/154760.119@webkitgtk/2.6
git-svn-id: https://svn.webkit.org/repository/webkit/releases/WebKitGTK/webkit-2.6@174973 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/WebCore/ChangeLog

@@ -1,3 +1,49 @@
+2014-10-16  Chris Dumez  <cdumez@apple.com>
+
+        Leverage the new RenderElement::m_isCSSAnimating flag in more places
+        https://bugs.webkit.org/show_bug.cgi?id=137786
+
+        Reviewed by Simon Fraser.
+
+        Leverage the new RenderElement::m_isCSSAnimating flag that was introduced
+        in r174703 in more places, for performance. This avoids doing extra work
+        for renderers on which we are not running animations on. This patch also
+        updates the API a bit to use more references instead of pointers, making
+        it clear the RenderElement cannot be null and thus avoiding unnecessary
+        null checks.
+
+        No new tests, no behavior change.
+
+        * css/CSSComputedStyleDeclaration.cpp:
+        (WebCore::computeRenderStyleForProperty):
+        * page/animation/AnimationController.cpp:
+        (WebCore::AnimationControllerPrivate::ensureCompositeAnimation):
+        (WebCore::AnimationControllerPrivate::clear):
+        (WebCore::AnimationControllerPrivate::updateAnimationTimerForRenderer):
+        (WebCore::AnimationControllerPrivate::isRunningAnimationOnRenderer):
+        (WebCore::AnimationControllerPrivate::isRunningAcceleratedAnimationOnRenderer):
+        (WebCore::AnimationControllerPrivate::pauseAnimationAtTime):
+        (WebCore::AnimationControllerPrivate::pauseTransitionAtTime):
+        (WebCore::AnimationControllerPrivate::getAnimatedStyleForRenderer):
+        (WebCore::AnimationController::cancelAnimations):
+        (WebCore::AnimationController::updateAnimations):
+        (WebCore::AnimationController::getAnimatedStyleForRenderer):
+        (WebCore::AnimationController::notifyAnimationStarted):
+        (WebCore::AnimationController::isRunningAnimationOnRenderer):
+        (WebCore::AnimationController::isRunningAcceleratedAnimationOnRenderer):
+        * page/animation/AnimationController.h:
+        * page/animation/AnimationControllerPrivate.h:
+        * rendering/RenderElement.cpp:
+        (WebCore::RenderElement::willBeDestroyed):
+        * rendering/RenderLayer.cpp:
+        (WebCore::RenderLayer::currentTransform):
+        * rendering/RenderLayerBacking.cpp:
+        (WebCore::RenderLayerBacking::updateGeometry):
+        (WebCore::RenderLayerBacking::notifyAnimationStarted):
+        * rendering/RenderLayerCompositor.cpp:
+        (WebCore::RenderLayerCompositor::requiresCompositingForAnimation):
+        (WebCore::RenderLayerCompositor::isRunningAcceleratedTransformAnimation):
+
 2014-10-14  Chris Dumez  <cdumez@apple.com>
 
         Introduce an isCSSAnimated flag on RenderElement for performance

Source/WebCore/css/CSSComputedStyleDeclaration.cpp

@@ -1664,7 +1664,7 @@ static inline PassRefPtr<RenderStyle> computeRenderStyleForProperty(Node* styled
 
     if (renderer && renderer->isComposited() && AnimationController::supportsAcceleratedAnimationOfProperty(propertyID)) {
         AnimationUpdateBlock animationUpdateBlock(&renderer->animation());
-        RefPtr<RenderStyle> style = renderer->animation().getAnimatedStyleForRenderer(toRenderElement(renderer));
+        RefPtr<RenderStyle> style = renderer->animation().getAnimatedStyleForRenderer(toRenderElement(*renderer));
         if (pseudoElementSpecifier && !styledNode->isPseudoElement()) {
             // FIXME: This cached pseudo style will only exist if the animation has been run at least once.
             return style->getCachedPseudoStyle(pseudoElementSpecifier);

Source/WebCore/page/animation/AnimationController.cpp

@@ -67,24 +67,25 @@ AnimationControllerPrivate::~AnimationControllerPrivate()
 {
 }
 
-CompositeAnimation& AnimationControllerPrivate::ensureCompositeAnimation(RenderElement* renderer)
+CompositeAnimation& AnimationControllerPrivate::ensureCompositeAnimation(RenderElement& renderer)
 {
-    auto result = m_compositeAnimations.add(renderer, nullptr);
+    auto result = m_compositeAnimations.add(&renderer, nullptr);
     if (result.isNewEntry) {
         result.iterator->value = CompositeAnimation::create(this);
-        renderer->setIsCSSAnimating(true);
+        renderer.setIsCSSAnimating(true);
     }
     return *result.iterator->value;
 }
 
-bool AnimationControllerPrivate::clear(RenderElement* renderer)
+bool AnimationControllerPrivate::clear(RenderElement& renderer)
 {
+    ASSERT(renderer.isCSSAnimating());
+    ASSERT(m_compositeAnimations.contains(&renderer));
     // Return false if we didn't do anything OR we are suspended (so we don't try to
     // do a setNeedsStyleRecalc() when suspended).
-    RefPtr<CompositeAnimation> animation = m_compositeAnimations.take(renderer);
-    if (!animation)
-        return false;
-    renderer->setIsCSSAnimating(false);
+    RefPtr<CompositeAnimation> animation = m_compositeAnimations.take(&renderer);
+    ASSERT(animation);
+    renderer.setIsCSSAnimating(false);
     animation->clearRenderer();
     return animation->isSuspended();
 }
@@ -119,11 +120,11 @@ double AnimationControllerPrivate::updateAnimations(SetChanged callSetChanged/*
     return timeToNextService;
 }
 
-void AnimationControllerPrivate::updateAnimationTimerForRenderer(RenderElement* renderer)
+void AnimationControllerPrivate::updateAnimationTimerForRenderer(RenderElement& renderer)
 {
     double timeToNextService = 0;
 
-    const CompositeAnimation* compositeAnimation = m_compositeAnimations.get(renderer);
+    const CompositeAnimation* compositeAnimation = m_compositeAnimations.get(&renderer);
     if (!compositeAnimation->isSuspended() && compositeAnimation->hasAnimations())
         timeToNextService = compositeAnimation->timeToNextService();
 
@@ -239,19 +240,19 @@ void AnimationControllerPrivate::animationTimerFired(Timer<AnimationControllerPr
     fireEventsAndUpdateStyle();
 }
 
-bool AnimationControllerPrivate::isRunningAnimationOnRenderer(RenderElement* renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
+bool AnimationControllerPrivate::isRunningAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
 {
-    ASSERT(renderer->isCSSAnimating());
-    ASSERT(m_compositeAnimations.contains(renderer));
-    const CompositeAnimation& animation = *m_compositeAnimations.get(renderer);
+    ASSERT(renderer.isCSSAnimating());
+    ASSERT(m_compositeAnimations.contains(&renderer));
+    const CompositeAnimation& animation = *m_compositeAnimations.get(&renderer);
     return animation.isAnimatingProperty(property, false, runningState);
 }
 
-bool AnimationControllerPrivate::isRunningAcceleratedAnimationOnRenderer(RenderElement* renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
+bool AnimationControllerPrivate::isRunningAcceleratedAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
 {
-    ASSERT(renderer->isCSSAnimating());
-    ASSERT(m_compositeAnimations.contains(renderer));
-    const CompositeAnimation& animation = *m_compositeAnimations.get(renderer);
+    ASSERT(renderer.isCSSAnimating());
+    ASSERT(m_compositeAnimations.contains(&renderer));
+    const CompositeAnimation& animation = *m_compositeAnimations.get(&renderer);
     return animation.isAnimatingProperty(property, true, runningState);
 }
 
@@ -323,7 +324,7 @@ bool AnimationControllerPrivate::pauseAnimationAtTime(RenderElement* renderer, c
     if (!renderer)
         return false;
 
-    CompositeAnimation& compositeAnimation = ensureCompositeAnimation(renderer);
+    CompositeAnimation& compositeAnimation = ensureCompositeAnimation(*renderer);
     if (compositeAnimation.pauseAnimationAtTime(name, t)) {
         renderer->element()->setNeedsStyleRecalc(SyntheticStyleChange);
         startUpdateStyleIfNeededDispatcher();
@@ -338,7 +339,7 @@ bool AnimationControllerPrivate::pauseTransitionAtTime(RenderElement* renderer,
     if (!renderer)
         return false;
 
-    CompositeAnimation& compositeAnimation = ensureCompositeAnimation(renderer);
+    CompositeAnimation& compositeAnimation = ensureCompositeAnimation(*renderer);
     if (compositeAnimation.pauseTransitionAtTime(cssPropertyID(property), t)) {
         renderer->element()->setNeedsStyleRecalc(SyntheticStyleChange);
         startUpdateStyleIfNeededDispatcher();
@@ -368,18 +369,14 @@ void AnimationControllerPrivate::receivedStartTimeResponse(double time)
     startTimeResponse(time);
 }
 
-PassRefPtr<RenderStyle> AnimationControllerPrivate::getAnimatedStyleForRenderer(RenderElement* renderer)
+PassRefPtr<RenderStyle> AnimationControllerPrivate::getAnimatedStyleForRenderer(RenderElement& renderer)
 {
-    if (!renderer)
-        return 0;
-
-    const CompositeAnimation* rendererAnimations = m_compositeAnimations.get(renderer);
-    if (!rendererAnimations)
-        return &renderer->style();
-
-    RefPtr<RenderStyle> animatingStyle = rendererAnimations->getAnimatedStyle();
+    ASSERT(renderer.isCSSAnimating());
+    ASSERT(m_compositeAnimations.contains(&renderer));
+    const CompositeAnimation& rendererAnimations = *m_compositeAnimations.get(&renderer);
+    RefPtr<RenderStyle> animatingStyle = rendererAnimations.getAnimatedStyle();
     if (!animatingStyle)
-        animatingStyle = &renderer->style();
+        animatingStyle = &renderer.style();
 
     return animatingStyle.release();
 }
@@ -479,17 +476,18 @@ AnimationController::~AnimationController()
 {
 }
 
-void AnimationController::cancelAnimations(RenderElement* renderer)
+void AnimationController::cancelAnimations(RenderElement& renderer)
 {
-    if (!m_data->hasAnimations())
+    if (!renderer.isCSSAnimating())
         return;
 
-    if (m_data->clear(renderer)) {
-        Element* element = renderer->element();
-        ASSERT(!element || !element->document().inPageCache());
-        if (element)
-            element->setNeedsStyleRecalc(SyntheticStyleChange);
-    }
+    if (!m_data->clear(renderer))
+        return;
+
+    Element* element = renderer.element();
+    ASSERT(!element || !element->document().inPageCache());
+    if (element)
+        element->setNeedsStyleRecalc(SyntheticStyleChange);
 }
 
 PassRef<RenderStyle> AnimationController::updateAnimations(RenderElement& renderer, PassRef<RenderStyle> newStyle)
@@ -517,11 +515,11 @@ PassRef<RenderStyle> AnimationController::updateAnimations(RenderElement& render
 
     Ref<RenderStyle> newStyleBeforeAnimation(WTF::move(newStyle));
 
-    CompositeAnimation& rendererAnimations = m_data->ensureCompositeAnimation(&renderer);
+    CompositeAnimation& rendererAnimations = m_data->ensureCompositeAnimation(renderer);
     auto blendedStyle = rendererAnimations.animate(renderer, oldStyle, newStyleBeforeAnimation.get());
 
     if (renderer.parent() || newStyleBeforeAnimation->animations() || (oldStyle && oldStyle->animations())) {
-        m_data->updateAnimationTimerForRenderer(&renderer);
+        m_data->updateAnimationTimerForRenderer(renderer);
 #if ENABLE(REQUEST_ANIMATION_FRAME)
         renderer.view().frameView().scheduleAnimation();
 #endif
@@ -537,12 +535,14 @@ PassRef<RenderStyle> AnimationController::updateAnimations(RenderElement& render
     return blendedStyle;
 }
 
-PassRefPtr<RenderStyle> AnimationController::getAnimatedStyleForRenderer(RenderElement* renderer)
+PassRefPtr<RenderStyle> AnimationController::getAnimatedStyleForRenderer(RenderElement& renderer)
 {
+    if (!renderer.isCSSAnimating())
+        return &renderer.style();
     return m_data->getAnimatedStyleForRenderer(renderer);
 }
 
-void AnimationController::notifyAnimationStarted(RenderElement*, double startTime)
+void AnimationController::notifyAnimationStarted(RenderElement&, double startTime)
 {
     m_data->receivedStartTimeResponse(startTime);
 }
@@ -562,14 +562,14 @@ bool AnimationController::pauseTransitionAtTime(RenderElement* renderer, const S
     return m_data->pauseTransitionAtTime(renderer, property, t);
 }
 
-bool AnimationController::isRunningAnimationOnRenderer(RenderElement* renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
+bool AnimationController::isRunningAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
 {
-    return renderer->isCSSAnimating() && m_data->isRunningAnimationOnRenderer(renderer, property, runningState);
+    return renderer.isCSSAnimating() && m_data->isRunningAnimationOnRenderer(renderer, property, runningState);
 }
 
-bool AnimationController::isRunningAcceleratedAnimationOnRenderer(RenderElement* renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
+bool AnimationController::isRunningAcceleratedAnimationOnRenderer(RenderElement& renderer, CSSPropertyID property, AnimationBase::RunningState runningState) const
 {
-    return renderer->isCSSAnimating() && m_data->isRunningAcceleratedAnimationOnRenderer(renderer, property, runningState);
+    return renderer.isCSSAnimating() && m_data->isRunningAcceleratedAnimationOnRenderer(renderer, property, runningState);
 }
 
 bool AnimationController::isSuspended() const

Source/WebCore/page/animation/AnimationController.h

@@ -47,19 +47,19 @@ class AnimationController {
     explicit AnimationController(Frame&);
     ~AnimationController();
 
-    void cancelAnimations(RenderElement*);
+    void cancelAnimations(RenderElement&);
     PassRef<RenderStyle> updateAnimations(RenderElement&, PassRef<RenderStyle> newStyle);
-    PassRefPtr<RenderStyle> getAnimatedStyleForRenderer(RenderElement*);
+    PassRefPtr<RenderStyle> getAnimatedStyleForRenderer(RenderElement&);
 
     // This is called when an accelerated animation or transition has actually started to animate.
-    void notifyAnimationStarted(RenderElement*, double startTime);
+    void notifyAnimationStarted(RenderElement&, double startTime);
 
     WEBCORE_EXPORT bool pauseAnimationAtTime(RenderElement*, const AtomicString& name, double t); // To be used only for testing
     WEBCORE_EXPORT bool pauseTransitionAtTime(RenderElement*, const String& property, double t); // To be used only for testing
     WEBCORE_EXPORT unsigned numberOfActiveAnimations(Document*) const; // To be used only for testing
 
-    bool isRunningAnimationOnRenderer(RenderElement*, CSSPropertyID, AnimationBase::RunningState) const;
-    bool isRunningAcceleratedAnimationOnRenderer(RenderElement*, CSSPropertyID, AnimationBase::RunningState) const;
+    bool isRunningAnimationOnRenderer(RenderElement&, CSSPropertyID, AnimationBase::RunningState) const;
+    bool isRunningAcceleratedAnimationOnRenderer(RenderElement&, CSSPropertyID, AnimationBase::RunningState) const;
 
     WEBCORE_EXPORT bool isSuspended() const;
     WEBCORE_EXPORT void suspendAnimations();

Source/WebCore/page/animation/AnimationControllerPrivate.h

@@ -65,8 +65,8 @@ class AnimationControllerPrivate {
     double updateAnimations(SetChanged callSetChanged = DoNotCallSetChanged);
     void updateAnimationTimer(SetChanged callSetChanged = DoNotCallSetChanged);
 
-    CompositeAnimation& ensureCompositeAnimation(RenderElement*);
-    bool clear(RenderElement*);
+    CompositeAnimation& ensureCompositeAnimation(RenderElement&);
+    bool clear(RenderElement&);
 
     void updateStyleIfNeededDispatcherFired(Timer<AnimationControllerPrivate>&);
     void startUpdateStyleIfNeededDispatcher();
@@ -86,14 +86,14 @@ class AnimationControllerPrivate {
     void resumeAnimationsForDocument(Document*);
     void startAnimationsIfNotSuspended(Document*);
 
-    bool isRunningAnimationOnRenderer(RenderElement*, CSSPropertyID, AnimationBase::RunningState) const;
-    bool isRunningAcceleratedAnimationOnRenderer(RenderElement*, CSSPropertyID, AnimationBase::RunningState) const;
+    bool isRunningAnimationOnRenderer(RenderElement&, CSSPropertyID, AnimationBase::RunningState) const;
+    bool isRunningAcceleratedAnimationOnRenderer(RenderElement&, CSSPropertyID, AnimationBase::RunningState) const;
 
     bool pauseAnimationAtTime(RenderElement*, const AtomicString& name, double t);
     bool pauseTransitionAtTime(RenderElement*, const String& property, double t);
     unsigned numberOfActiveAnimations(Document*) const;
 
-    PassRefPtr<RenderStyle> getAnimatedStyleForRenderer(RenderElement* renderer);
+    PassRefPtr<RenderStyle> getAnimatedStyleForRenderer(RenderElement&);
 
     double beginAnimationUpdateTime();
     void setBeginAnimationUpdateTime(double t) { m_beginAnimationUpdateTime = t; }
@@ -108,7 +108,7 @@ class AnimationControllerPrivate {
 
     void animationWillBeRemoved(AnimationBase*);
 
-    void updateAnimationTimerForRenderer(RenderElement*);
+    void updateAnimationTimerForRenderer(RenderElement&);
 
     bool allowsNewAnimationsWhileSuspended() const { return m_allowsNewAnimationsWhileSuspended; }
     void setAllowsNewAnimationsWhileSuspended(bool);

Source/WebCore/rendering/RenderElement.cpp

@@ -1006,7 +1006,7 @@ void RenderElement::willBeRemovedFromTree()
 
 void RenderElement::willBeDestroyed()
 {
-    animation().cancelAnimations(this);
+    animation().cancelAnimations(*this);
 
     destroyLeftoverChildren();
 

Source/WebCore/rendering/RenderLayer.cpp

@@ -867,7 +867,7 @@ TransformationMatrix RenderLayer::currentTransform(RenderStyle::ApplyTransformOr
     FloatRect pixelSnappedBorderRect = snapRectToDevicePixels(box->borderBoxRect(), box->document().deviceScaleFactor());
     if (renderer().style().isRunningAcceleratedAnimation()) {
         TransformationMatrix currTransform;
-        RefPtr<RenderStyle> style = renderer().animation().getAnimatedStyleForRenderer(&renderer());
+        RefPtr<RenderStyle> style = renderer().animation().getAnimatedStyleForRenderer(renderer());
         style->applyTransform(currTransform, pixelSnappedBorderRect, applyOrigin);
         makeMatrixRenderable(currTransform, canRender3DTransforms());
         return currTransform;

Source/WebCore/rendering/RenderLayerBacking.cpp

@@ -642,11 +642,11 @@ void RenderLayerBacking::updateGeometry()
 
     // Set transform property, if it is not animating. We have to do this here because the transform
     // is affected by the layer dimensions.
-    if (!renderer().animation().isRunningAcceleratedAnimationOnRenderer(&renderer(), CSSPropertyWebkitTransform, AnimationBase::Running | AnimationBase::Paused | AnimationBase::FillingFowards))
+    if (!renderer().animation().isRunningAcceleratedAnimationOnRenderer(renderer(), CSSPropertyWebkitTransform, AnimationBase::Running | AnimationBase::Paused | AnimationBase::FillingFowards))
         updateTransform(style);
 
     // Set opacity, if it is not animating.
-    if (!renderer().animation().isRunningAcceleratedAnimationOnRenderer(&renderer(), CSSPropertyOpacity, AnimationBase::Running | AnimationBase::Paused | AnimationBase::FillingFowards))
+    if (!renderer().animation().isRunningAcceleratedAnimationOnRenderer(renderer(), CSSPropertyOpacity, AnimationBase::Running | AnimationBase::Paused | AnimationBase::FillingFowards))
         updateOpacity(style);
 
     updateFilters(style);
@@ -2445,7 +2445,7 @@ void RenderLayerBacking::transitionFinished(CSSPropertyID property)
 
 void RenderLayerBacking::notifyAnimationStarted(const GraphicsLayer*, const String&, double time)
 {
-    renderer().animation().notifyAnimationStarted(&renderer(), time);
+    renderer().animation().notifyAnimationStarted(renderer(), time);
 }
 
 void RenderLayerBacking::notifyFlushRequired(const GraphicsLayer* layer)