Changeset 183454 in webkit


Ignore:
Timestamp:
Apr 27, 2015, 9:59:48 PM (10 years ago)
Author:
Simon Fraser
Message:

Eliminate styleDidChange with StyleDifferenceEqual when updates are actually necessary
​https://bugs.webkit.org/show_bug.cgi?id=144198

Reviewed by Darin Adler, Antti Koivisto.

Source/WebCore:

SyntheticStyleChange style recalcs are triggered for cases where behavior depends
on state which is outside of RenderStyle; this includes triggering compositing for
animations, for video and canvas, and for iframes with composited content.

In these cases, we'd run through RenderElement::setStyle() and its fan-out, but
with diff == StyleDifferenceEqual, and so be unable to determine if there
is actual work to be done.

This patch enforces the contract that the diff is never StyleDifferenceEqual if
compositing or other work has to happen from setStyle(). This is achieved by
passing in a 'hasSideEffects' flag, which causes the diff to become at least
StyleDifferenceRecompositeLayer.

RenderLayerCompositor::layerStyleChanged() can now safely early return
if the diff is equal. Future patches will reduce redundant work even more.

Test: compositing/animation/no-style-recalc-during-accelerated-animation.html

  • page/animation/AnimationBase.h:

(WebCore::AnimationBase::animate): Returns a bool now if the state changed.
(WebCore::AnimationBase::state):

  • page/animation/AnimationController.cpp:

(WebCore::AnimationController::updateAnimations): bool out param which indicates
whether any animations changed state.

  • page/animation/AnimationController.h:
  • page/animation/CompositeAnimation.cpp:

(WebCore::CompositeAnimation::animate): If any transitions or animations changed
state, set the animationStateChanged out param to true.

  • page/animation/CompositeAnimation.h:
  • page/animation/ImplicitAnimation.cpp:

(WebCore::ImplicitAnimation::animate): Return true if the state changed.

  • page/animation/ImplicitAnimation.h:
  • page/animation/KeyframeAnimation.cpp:

(WebCore::KeyframeAnimation::animate): Return true if the state changed.

  • page/animation/KeyframeAnimation.h:
  • rendering/RenderElement.cpp:

(WebCore::RenderElement::adjustStyleDifference): We may enter here now with diff
!= StyleDifferenceEqual, but still need to do the check to see if layers changed.
(WebCore::RenderElement::initializeStyle): When setting style for the first time,
don't use StyleDifferenceEqual.
(WebCore::RenderElement::setStyle): Additional flag to indicate whether this style
change involves side effects. If the diff is equal but the flag is set, change
the diff to StyleDifferenceRecompositeLayer (the "lowest" non-zero diff).

  • rendering/RenderElement.h:

(WebCore::RenderElement::setAnimatableStyle): Pass true to setStyle() if hasSideEffects
is true, or if animation state changed.

  • rendering/RenderLayer.cpp:

(WebCore::RenderLayer::styleChanged): Pass the diff down.

  • rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::layerStyleChanged): Return if the diff is equal.

  • rendering/RenderLayerCompositor.h:
  • rendering/style/RenderStyleConstants.h: StyleDifferenceNewStyle is used when

setting style for the first time.

  • style/StyleResolveTree.cpp:

(WebCore::Style::createRendererIfNeeded): Provide animationsChanged bool (which is unused).
(WebCore::Style::resolveLocal): If the style change is synthetic, set the flag that
says there are side-effects.

LayoutTests:

New test that detects whether a "hardware" animation is firing the style recalc
timer on every frame, which happened during development of this patch.

  • compositing/animation/no-style-recalc-during-accelerated-animation-expected.txt: Added.
  • compositing/animation/no-style-recalc-during-accelerated-animation.html: Added.
Location:
trunk
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r183450 r183454  
     12015-04-25  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Eliminate styleDidChange with StyleDifferenceEqual when updates are actually necessary
     4        https://bugs.webkit.org/show_bug.cgi?id=144198
     5
     6        Reviewed by Darin Adler, Antti Koivisto.
     7       
     8        New test that detects whether a "hardware" animation is firing the style recalc
     9        timer on every frame, which happened during development of this patch.
     10
     11        * compositing/animation/no-style-recalc-during-accelerated-animation-expected.txt: Added.
     12        * compositing/animation/no-style-recalc-during-accelerated-animation.html: Added.
     13
    1142015-04-27  Benjamin Poulain  <bpoulain@apple.com>
    215

  • trunk/Source/WebCore/ChangeLog

    r183452 r183454  
     12015-04-25  Simon Fraser  <simon.fraser@apple.com>
     2
     3        Eliminate styleDidChange with StyleDifferenceEqual when updates are actually necessary
     4        https://bugs.webkit.org/show_bug.cgi?id=144198
     5
     6        Reviewed by Darin Adler, Antti Koivisto.
     7       
     8        SyntheticStyleChange style recalcs are triggered for cases where behavior depends
     9        on state which is outside of RenderStyle; this includes triggering compositing for
     10        animations, for video and canvas, and for iframes with composited content.
     11       
     12        In these cases, we'd run through RenderElement::setStyle() and its fan-out, but
     13        with diff == StyleDifferenceEqual, and so be unable to determine if there
     14        is actual work to be done.
     15       
     16        This patch enforces the contract that the diff is never StyleDifferenceEqual if
     17        compositing or other work has to happen from setStyle(). This is achieved by
     18        passing in a 'hasSideEffects' flag, which causes the diff to become at least
     19        StyleDifferenceRecompositeLayer.
     20       
     21        RenderLayerCompositor::layerStyleChanged() can now safely early return
     22        if the diff is equal. Future patches will reduce redundant work even more.
     23
     24        Test: compositing/animation/no-style-recalc-during-accelerated-animation.html
     25
     26        * page/animation/AnimationBase.h:
     27        (WebCore::AnimationBase::animate): Returns a bool now if the state changed.
     28        (WebCore::AnimationBase::state):
     29        * page/animation/AnimationController.cpp:
     30        (WebCore::AnimationController::updateAnimations): bool out param which indicates
     31        whether any animations changed state.
     32        * page/animation/AnimationController.h:
     33        * page/animation/CompositeAnimation.cpp:
     34        (WebCore::CompositeAnimation::animate): If any transitions or animations changed
     35        state, set the animationStateChanged out param to true.
     36        * page/animation/CompositeAnimation.h:
     37        * page/animation/ImplicitAnimation.cpp:
     38        (WebCore::ImplicitAnimation::animate): Return true if the state changed.
     39        * page/animation/ImplicitAnimation.h:
     40        * page/animation/KeyframeAnimation.cpp:
     41        (WebCore::KeyframeAnimation::animate): Return true if the state changed.
     42        * page/animation/KeyframeAnimation.h:
     43        * rendering/RenderElement.cpp:
     44        (WebCore::RenderElement::adjustStyleDifference): We may enter here now with diff
     45        != StyleDifferenceEqual, but still need to do the check to see if layers changed.
     46        (WebCore::RenderElement::initializeStyle): When setting style for the first time,
     47        don't use StyleDifferenceEqual.
     48        (WebCore::RenderElement::setStyle): Additional flag to indicate whether this style
     49        change involves side effects. If the diff is equal but the flag is set, change
     50        the diff to StyleDifferenceRecompositeLayer (the "lowest" non-zero diff).
     51        * rendering/RenderElement.h:
     52        (WebCore::RenderElement::setAnimatableStyle): Pass true to setStyle() if hasSideEffects
     53        is true, or if animation state changed.
     54        * rendering/RenderLayer.cpp:
     55        (WebCore::RenderLayer::styleChanged): Pass the diff down.
     56        * rendering/RenderLayerCompositor.cpp:
     57        (WebCore::RenderLayerCompositor::layerStyleChanged): Return if the diff is equal.
     58        * rendering/RenderLayerCompositor.h:
     59        * rendering/style/RenderStyleConstants.h: StyleDifferenceNewStyle is used when
     60        setting style for the first time.
     61        * style/StyleResolveTree.cpp:
     62        (WebCore::Style::createRendererIfNeeded): Provide animationsChanged bool (which is unused).
     63        (WebCore::Style::resolveLocal): If the style change is synthetic, set the flag that
     64        says there are side-effects.
     65
    1662015-04-27  Michael Catanzaro  <mcatanzaro@igalia.com>
    267

  • trunk/Source/WebCore/page/animation/AnimationBase.h

    r183364 r183454  
    136136    double progress(double scale, double offset, const TimingFunction*) const;
    137137
    138     virtual void animate(CompositeAnimation*, RenderElement*, const RenderStyle* /*currentStyle*/, RenderStyle* /*targetStyle*/, RefPtr<RenderStyle>& /*animatedStyle*/) = 0;
     138    // Returns true if the animation state changed.
     139    virtual bool animate(CompositeAnimation*, RenderElement*, const RenderStyle* /*currentStyle*/, RenderStyle* /*targetStyle*/, RefPtr<RenderStyle>& /*animatedStyle*/) = 0;
    139140    virtual void getAnimatedStyle(RefPtr<RenderStyle>& /*animatedStyle*/) = 0;
    140141
    … …  
    233234
    234235    bool isAccelerated() const { return m_isAccelerated; }
     236    AnimationState state() const { return m_animationState; }
    235237
    236238    static void setNeedsStyleRecalc(Element*);

  • trunk/Source/WebCore/page/animation/AnimationController.cpp

    r183364 r183454  
    569569}
    570570
    571 Ref<RenderStyle> AnimationController::updateAnimations(RenderElement& renderer, Ref<RenderStyle>&& newStyle)
    572 {
    573     // Don't do anything if we're in the cache
     571bool AnimationController::updateAnimations(RenderElement& renderer, RenderStyle& newStyle, Ref<RenderStyle>& animatedStyle)
     572{
     573    RenderStyle* oldStyle = renderer.hasInitializedStyle() ? &renderer.style() : nullptr;
     574    if ((!oldStyle || (!oldStyle->animations() && !oldStyle->transitions())) && (!newStyle.animations() && !newStyle.transitions()))
     575        return false;
     576
    574577    if (renderer.document().inPageCache())
    575         return WTF::move(newStyle);
    576 
    577     RenderStyle* oldStyle = renderer.hasInitializedStyle() ? &renderer.style() : nullptr;
    578 
    579     if ((!oldStyle || (!oldStyle->animations() && !oldStyle->transitions())) && (!newStyle.get().animations() && !newStyle.get().transitions()))
    580         return WTF::move(newStyle);
     578        return false;
    581579
    582580    // Don't run transitions when printing.
    583581    if (renderer.view().printing())
    584         return WTF::move(newStyle);
     582        return false;
    585583
    586584    // Fetch our current set of implicit animations from a hashtable.  We then compare them
    … …  
    592590    ASSERT(renderer.element());
    593591
    594     Ref<RenderStyle> newStyleBeforeAnimation(WTF::move(newStyle));
    595 
    596592    CompositeAnimation& rendererAnimations = m_data->ensureCompositeAnimation(renderer);
    597     auto blendedStyle = rendererAnimations.animate(renderer, oldStyle, newStyleBeforeAnimation);
    598 
    599     if (renderer.parent() || newStyleBeforeAnimation->animations() || (oldStyle && oldStyle->animations())) {
     593    bool animationStateChanged = rendererAnimations.animate(renderer, oldStyle, newStyle, animatedStyle);
     594
     595    if (renderer.parent() || newStyle.animations() || (oldStyle && oldStyle->animations())) {
    600596        m_data->updateAnimationTimerForRenderer(renderer);
    601597#if ENABLE(REQUEST_ANIMATION_FRAME)
    … …  
    604600    }
    605601
    606     if (blendedStyle.ptr() != newStyleBeforeAnimation.ptr()) {
     602    if (animatedStyle.ptr() != &newStyle) {
    607603        // If the animations/transitions change opacity or transform, we need to update
    608604        // the style to impose the stacking rules. Note that this is also
    609605        // done in StyleResolver::adjustRenderStyle().
    610         if (blendedStyle.get().hasAutoZIndex() && (blendedStyle.get().opacity() < 1.0f || blendedStyle.get().hasTransform()))
    611             blendedStyle.get().setZIndex(0);
    612     }
    613     return blendedStyle;
     606        if (animatedStyle.get().hasAutoZIndex() && (animatedStyle.get().opacity() < 1.0f || animatedStyle.get().hasTransform()))
     607            animatedStyle.get().setZIndex(0);
     608    }
     609    return animationStateChanged;
    614610}
    615611

  • trunk/Source/WebCore/page/animation/AnimationController.h

    r183295 r183454  
    5050
    5151    void cancelAnimations(RenderElement&);
    52     Ref<RenderStyle> updateAnimations(RenderElement&, Ref<RenderStyle>&& newStyle);
     52    bool updateAnimations(RenderElement&, RenderStyle& newStyle, Ref<RenderStyle>& animatedStyle);
    5353    PassRefPtr<RenderStyle> getAnimatedStyleForRenderer(RenderElement&);
    5454

  • trunk/Source/WebCore/page/animation/CompositeAnimation.cpp

    r183364 r183454  
    298298}
    299299
    300 Ref<RenderStyle> CompositeAnimation::animate(RenderElement& renderer, RenderStyle* currentStyle, RenderStyle& targetStyle)
    301 {
    302     RefPtr<RenderStyle> resultStyle;
    303 
     300bool CompositeAnimation::animate(RenderElement& renderer, RenderStyle* currentStyle, RenderStyle& targetStyle, Ref<RenderStyle>& blendedStyle)
     301{
    304302    // We don't do any transitions if we don't have a currentStyle (on startup).
    305303    updateTransitions(&renderer, currentStyle, &targetStyle);
    … …  
    307305    m_keyframeAnimations.checkConsistency();
    308306
     307    RefPtr<RenderStyle> animatedStyle;
     308    bool animationStateChanged = false;
     309
    309310    if (currentStyle) {
    310311        // Now that we have transition objects ready, let them know about the new goal state.  We want them
    311312        // to fill in a RenderStyle*& only if needed.
    312         if (!m_transitions.isEmpty()) {
    313             for (auto& transition : m_transitions.values())
    314                 transition->animate(this, &renderer, currentStyle, &targetStyle, resultStyle);
     313        for (auto& transition : m_transitions.values()) {
     314            if (transition->animate(this, &renderer, currentStyle, &targetStyle, animatedStyle))
     315                animationStateChanged = true;
    315316        }
    316317    }
    … …  
    320321    for (auto& name : m_keyframeAnimationOrderMap) {
    321322        RefPtr<KeyframeAnimation> keyframeAnim = m_keyframeAnimations.get(name);
    322         if (keyframeAnim)
    323             keyframeAnim->animate(this, &renderer, currentStyle, &targetStyle, resultStyle);
    324     }
    325 
    326     if (resultStyle)
    327         return resultStyle.releaseNonNull();
    328 
    329     return targetStyle;
     323        if (keyframeAnim && keyframeAnim->animate(this, &renderer, currentStyle, &targetStyle, animatedStyle))
     324            animationStateChanged = true;
     325    }
     326
     327    if (animatedStyle)
     328        blendedStyle = animatedStyle.releaseNonNull();
     329    else
     330        blendedStyle = targetStyle;
     331
     332    return animationStateChanged;
    330333}
    331334

  • trunk/Source/WebCore/page/animation/CompositeAnimation.h

    r183364 r183454  
    5757    void clearRenderer();
    5858
    59     Ref<RenderStyle> animate(RenderElement&, RenderStyle* currentStyle, RenderStyle& targetStyle);
     59    bool animate(RenderElement&, RenderStyle* currentStyle, RenderStyle& targetStyle, Ref<RenderStyle>& blendedStyle);
    6060    PassRefPtr<RenderStyle> getAnimatedStyle() const;
    6161    bool computeExtentOfTransformAnimation(LayoutRect&) const;

  • trunk/Source/WebCore/page/animation/ImplicitAnimation.cpp

    r183364 r183454  
    6161}
    6262
    63 void ImplicitAnimation::animate(CompositeAnimation*, RenderElement*, const RenderStyle*, RenderStyle* targetStyle, RefPtr<RenderStyle>& animatedStyle)
     63bool ImplicitAnimation::animate(CompositeAnimation*, RenderElement*, const RenderStyle*, RenderStyle* targetStyle, RefPtr<RenderStyle>& animatedStyle)
    6464{
    6565    // If we get this far and the animation is done, it means we are cleaning up a just finished animation.
    6666    // So just return. Everything is already all cleaned up.
    6767    if (postActive())
    68         return;
     68        return false;
     69
     70    AnimationState oldState = state();
    6971
    7072    // Reset to start the transition if we are new
    … …  
    8082    // FIXME: we also need to detect cases where we have to software animate for other reasons,
    8183    // such as a child using inheriting the transform. https://bugs.webkit.org/show_bug.cgi?id=23902
    82     if (!needsAnim)
     84    if (!needsAnim) {
    8385        // If we are running an accelerated animation, set a flag in the style which causes the style
    8486        // to compare as different to any other style. This ensures that changes to the property
    8587        // that is animating are correctly detected during the animation (e.g. when a transition
    8688        // gets interrupted).
     89        // FIXME: still need this hack?
    8790        animatedStyle->setIsRunningAcceleratedAnimation();
     91    }
    8892
    8993    // Fire the start timeout if needed
    9094    fireAnimationEventsIfNeeded();
     95    return state() != oldState;
    9196}
    9297

  • trunk/Source/WebCore/page/animation/ImplicitAnimation.h

    r183364 r183454  
    5555    virtual void endAnimation() override;
    5656
    57     virtual void animate(CompositeAnimation*, RenderElement*, const RenderStyle* currentStyle, RenderStyle* targetStyle, RefPtr<RenderStyle>& animatedStyle) override;
     57    virtual bool animate(CompositeAnimation*, RenderElement*, const RenderStyle* currentStyle, RenderStyle* targetStyle, RefPtr<RenderStyle>& animatedStyle) override;
    5858    virtual void getAnimatedStyle(RefPtr<RenderStyle>& animatedStyle) override;
    5959    virtual void reset(RenderStyle* to);

  • trunk/Source/WebCore/page/animation/KeyframeAnimation.cpp

    r183364 r183454  
    119119}
    120120
    121 void KeyframeAnimation::animate(CompositeAnimation* compositeAnimation, RenderElement*, const RenderStyle*, RenderStyle* targetStyle, RefPtr<RenderStyle>& animatedStyle)
     121bool KeyframeAnimation::animate(CompositeAnimation* compositeAnimation, RenderElement*, const RenderStyle*, RenderStyle* targetStyle, RefPtr<RenderStyle>& animatedStyle)
    122122{
    123123    // Fire the start timeout if needed
    … …  
    133133        if (!animatedStyle)
    134134            animatedStyle = const_cast<RenderStyle*>(targetStyle);
    135         return;
     135        return false;
    136136    }
    137137
    … …  
    142142    // through to the style blend so that we get the fromStyle.
    143143    if (waitingToStart() && m_animation->delay() > 0 && !m_animation->fillsBackwards())
    144         return;
     144        return false;
    145145   
    146146    // If we have no keyframes, don't animate.
    147147    if (!m_keyframes.size()) {
    148148        updateStateMachine(AnimationStateInput::EndAnimation, -1);
    149         return;
    150     }
     149        return false;
     150    }
     151
     152    AnimationState oldState = state();
    151153
    152154    // Run a cycle of animation.
    … …  
    169171            // to indicate it. This can be used to make sure we get an updated
    170172            // style for hit testing, etc.
     173            // FIXME: still need this?
    171174            animatedStyle->setIsRunningAcceleratedAnimation();
    172175    }
     176   
     177    return state() != oldState;
    173178}
    174179

  • trunk/Source/WebCore/page/animation/KeyframeAnimation.h

    r183364 r183454  
    4646    }
    4747
    48     virtual void animate(CompositeAnimation*, RenderElement*, const RenderStyle* currentStyle, RenderStyle* targetStyle, RefPtr<RenderStyle>& animatedStyle) override;
     48    virtual bool animate(CompositeAnimation*, RenderElement*, const RenderStyle* currentStyle, RenderStyle* targetStyle, RefPtr<RenderStyle>& animatedStyle) override;
    4949    virtual void getAnimatedStyle(RefPtr<RenderStyle>&) override;
    5050

  • trunk/Source/WebCore/rendering/RenderElement.cpp

    r183160 r183454  
    297297    // style changing, since it depends on whether we decide to composite these elements. When the
    298298    // layer status of one of these elements changes, we need to force a layout.
    299     if (diff == StyleDifferenceEqual && isRenderLayerModelObject()) {
     299    if (diff < StyleDifferenceLayout && isRenderLayerModelObject()) {
    300300        if (hasLayer() != downcast<RenderLayerModelObject>(*this).requiresLayer())
    301301            diff = StyleDifferenceLayout;
    … …  
    367367void RenderElement::initializeStyle()
    368368{
    369     styleWillChange(StyleDifferenceEqual, style());
     369    styleWillChange(StyleDifferenceNewStyle, style());
    370370
    371371    m_hasInitializedStyle = true;
    … …  
    386386        view().setMaximalOutlineSize(std::max(theme().platformFocusRingMaxWidth(), static_cast<int>(m_style->outlineSize())));
    387387
    388     styleDidChange(StyleDifferenceEqual, nullptr);
     388    styleDidChange(StyleDifferenceNewStyle, nullptr);
    389389
    390390    // We shouldn't have any text children that would need styleDidChange at this point.
    … …  
    395395}
    396396
    397 void RenderElement::setStyle(Ref<RenderStyle>&& style)
     397void RenderElement::setStyle(Ref<RenderStyle>&& style, StyleDifference minimalStyleDifference)
    398398{
    399399    // FIXME: Should change RenderView so it can use initializeStyle too.
    … …  
    409409        ASSERT(!isEmbeddedObject());
    410410        ASSERT(!isCanvas());
     411        ASSERT(minimalStyleDifference == StyleDifferenceEqual);
    411412        return;
    412413    }
    … …  
    416417    if (m_hasInitializedStyle)
    417418        diff = m_style->diff(style.get(), contextSensitiveProperties);
     419
     420    diff = std::max(diff, minimalStyleDifference);
    418421
    419422    diff = adjustStyleDifference(diff, contextSensitiveProperties);

  • trunk/Source/WebCore/rendering/RenderElement.h

    r181691 r183454  
    4545    void initializeStyle();
    4646
    47     void setStyle(Ref<RenderStyle>&&);
     47    // Calling with minimalStyleDifference > StyleDifferenceEqual indicates that
     48    // out-of-band state (e.g. animations) requires that styleDidChange processing
     49    // continue even if the style isn't different from the current style.
     50    void setStyle(Ref<RenderStyle>&&, StyleDifference minimalStyleDifference = StyleDifferenceEqual);
     51
    4852    // Called to update a style that is allowed to trigger animations.
    49     void setAnimatableStyle(Ref<RenderStyle>&&);
     53    void setAnimatableStyle(Ref<RenderStyle>&&, StyleDifference minimalStyleDifference);
    5054
    5155    // The pseudo element style can be cached or uncached.  Use the cached method if the pseudo element doesn't respect
    5256    // any pseudo classes (and therefore has no concept of changing state).
    53     RenderStyle* getCachedPseudoStyle(PseudoId, RenderStyle* parentStyle = 0) const;
    54     PassRefPtr<RenderStyle> getUncachedPseudoStyle(const PseudoStyleRequest&, RenderStyle* parentStyle = 0, RenderStyle* ownStyle = 0) const;
     57    RenderStyle* getCachedPseudoStyle(PseudoId, RenderStyle* parentStyle = nullptr) const;
     58    PassRefPtr<RenderStyle> getUncachedPseudoStyle(const PseudoStyleRequest&, RenderStyle* parentStyle = nullptr, RenderStyle* ownStyle = nullptr) const;
    5559
    5660    // This is null for anonymous renderers.
    … …  
    8993
    9094    virtual bool isChildAllowed(const RenderObject&, const RenderStyle&) const { return true; }
    91     virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = 0);
    92     virtual void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild = 0) { return addChild(newChild, beforeChild); }
     95    virtual void addChild(RenderObject* newChild, RenderObject* beforeChild = nullptr);
     96    virtual void addChildIgnoringContinuation(RenderObject* newChild, RenderObject* beforeChild = nullptr) { return addChild(newChild, beforeChild); }
    9397    virtual void removeChild(RenderObject&);
    9498
    … …  
    323327};
    324328
    325 inline void RenderElement::setAnimatableStyle(Ref<RenderStyle>&& style)
    326 {
    327     setStyle(animation().updateAnimations(*this, WTF::move(style)));
     329inline void RenderElement::setAnimatableStyle(Ref<RenderStyle>&& style, StyleDifference minimalStyleDifference)
     330{
     331    Ref<RenderStyle> animatedStyle = WTF::move(style);
     332    if (animation().updateAnimations(*this, animatedStyle, animatedStyle))
     333        minimalStyleDifference = std::max(minimalStyleDifference, StyleDifferenceRecompositeLayer);
     334   
     335    setStyle(WTF::move(animatedStyle), minimalStyleDifference);
    328336}
    329337

  • trunk/Source/WebCore/rendering/RenderLayer.cpp

    r183364 r183454  
    66946694    updateNeedsCompositedScrolling();
    66956695
    6696     compositor().layerStyleChanged(*this, oldStyle);
     6696    compositor().layerStyleChanged(diff, *this, oldStyle);
    66976697
    66986698    updateOrRemoveFilterEffectRenderer();

  • trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

    r183314 r183454  
    916916}
    917917
    918 void RenderLayerCompositor::layerStyleChanged(RenderLayer& layer, const RenderStyle* oldStyle)
    919 {
     918void RenderLayerCompositor::layerStyleChanged(StyleDifference diff, RenderLayer& layer, const RenderStyle* oldStyle)
     919{
     920    if (diff == StyleDifferenceEqual)
     921        return;
     922
    920923    const RenderStyle& newStyle = layer.renderer().style();
    921924    if (updateLayerCompositingState(layer) || (oldStyle && styleChangeRequiresLayerRebuild(layer, *oldStyle, newStyle)))

  • trunk/Source/WebCore/rendering/RenderLayerCompositor.h

    r182985 r183454  
    172172    void layerWillBeRemoved(RenderLayer& parent, RenderLayer& child);
    173173
    174     void layerStyleChanged(RenderLayer&, const RenderStyle* oldStyle);
     174    void layerStyleChanged(StyleDifference, RenderLayer&, const RenderStyle* oldStyle);
    175175
    176176    static bool canCompositeClipPath(const RenderLayer&);

  • trunk/Source/WebCore/rendering/style/RenderStyle.h

    r183399 r183454  
    10641064    AnimationList* animations() { return rareNonInheritedData->m_animations.get(); }
    10651065    AnimationList* transitions() { return rareNonInheritedData->m_transitions.get(); }
     1066   
     1067    bool hasAnimationsOrTransitions() const { return rareNonInheritedData->hasAnimationsOrTransitions(); }
    10661068
    10671069    AnimationList& ensureAnimations();

  • trunk/Source/WebCore/rendering/style/RenderStyleConstants.h

    r183304 r183454  
    5656    StyleDifferenceSimplifiedLayout,
    5757    StyleDifferenceSimplifiedLayoutAndPositionedMovement,
    58     StyleDifferenceLayout
     58    StyleDifferenceLayout,
     59    StyleDifferenceNewStyle
    5960};
    6061

  • trunk/Source/WebCore/rendering/style/StyleRareNonInheritedData.h

    r182613 r183454  
    100100    bool hasOpacity() const { return opacity < 1; }
    101101
     102    bool hasAnimationsOrTransitions() const { return m_animations || m_transitions; }
     103
    102104    float opacity;
    103105

  • trunk/Source/WebCore/style/StyleResolveTree.cpp

    r183160 r183454  
    202202    // FIXME: There's probably a better way to factor this.
    203203    // This just does what setAnimatedStyle() does, except with setStyleInternal() instead of setStyle().
    204     newRenderer->setStyleInternal(newRenderer->animation().updateAnimations(*newRenderer, newRenderer->style()));
     204    Ref<RenderStyle> animatedStyle = newRenderer->style();
     205    newRenderer->animation().updateAnimations(*newRenderer, animatedStyle, animatedStyle);
     206    newRenderer->setStyleInternal(WTF::move(animatedStyle));
    205207
    206208    newRenderer->initializeStyle();
    … …  
    631633    if (RenderElement* renderer = current.renderer()) {
    632634        if (localChange != NoChange || pseudoStyleCacheIsInvalid(renderer, newStyle.get()) || (inheritedChange == Force && renderer->requiresForcedStyleRecalcPropagation()) || current.styleChangeType() == SyntheticStyleChange)
    633             renderer->setAnimatableStyle(*newStyle);
     635            renderer->setAnimatableStyle(*newStyle, current.styleChangeType() == SyntheticStyleChange ? StyleDifferenceRecompositeLayer : StyleDifferenceEqual);
    634636        else if (current.needsStyleRecalc()) {
    635637            // Although no change occurred, we use the new style so that the cousin style sharing code won't get
Note: See TracChangeset for help on using the changeset viewer.