[SCM] WebKit Debian packaging branch, debian/experimental, updated. upstream/1.3.3-9427-gc2be6fc
simon.fraser at apple.com
simon.fraser at apple.com
Wed Dec 22 11:17:21 UTC 2010
The following commit has been merged in the debian/experimental branch:
commit 2a45c85a41c64ad3048dac5bc551e3b7bff73432
Author: simon.fraser at apple.com <simon.fraser at apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Date: Fri Jul 16 20:31:24 2010 +0000
2010-07-16 Simon Fraser <simon.fraser at apple.com>
Reviewed by Sam Weinig.
Safari pegs CPU and drops frames on http://neography.com/experiment/circles/solarsystem/ (CSS animations)
https://bugs.webkit.org/show_bug.cgi?id=41409
AnimationController::isAnimatingPropertyOnRenderer() really asked whether an accelerated animation
or transition was running. This prevented us from falling into compositing layers for animation
on platforms, like Windows, that don't have accelerated animations.
Fix by making things more explicit: we now have two methods, isRunningAnimationOnRenderer()
and isRunningAcceleratedAnimationOnRenderer().
Changes are more extensive because I flipped the sense of 'm_fallbackAnimating', which is
now 'm_isAccelerated', for clarity.
Test: compositing/animation/animation-compositing.html
* page/animation/AnimationBase.cpp:
(WebCore::AnimationBase::AnimationBase): m_fallbackAnimating -> m_isAccelerated
(WebCore::AnimationBase::blendProperties): Ditto.
(WebCore::AnimationBase::updateStateMachine): Ditto.
* page/animation/AnimationBase.h:
(WebCore::AnimationBase::isAnimatingProperty): Takes new acceleratedOnly parameter
which causes the method to only return true if the animation is accelerated.
(WebCore::AnimationBase::isAccelerated): Changed from isFallbackAnimating.
* page/animation/AnimationController.cpp:
(WebCore::AnimationControllerPrivate::isRunningAnimationOnRenderer):
(WebCore::AnimationControllerPrivate::isRunningAcceleratedAnimationOnRenderer):
(WebCore::AnimationController::isRunningAnimationOnRenderer):
(WebCore::AnimationController::isRunningAcceleratedAnimationOnRenderer):
* page/animation/CompositeAnimation.h:
* page/animation/AnimationController.h: Rename isAnimatingPropertyOnRenderer(), add
isRunningAcceleratedAnimationOnRenderer().
* page/animation/AnimationControllerPrivate.h: Ditto.
* page/animation/CompositeAnimation.cpp:
(WebCore::CompositeAnimation::updateTransitions): !isFallbackAnimating() -> isAccelerated().
(WebCore::CompositeAnimation::isAnimatingProperty): Pass acceleratedOnly down.
* page/animation/ImplicitAnimation.cpp:
(WebCore::ImplicitAnimation::timeToNextService): !isFallbackAnimating() -> isAccelerated().
* page/animation/KeyframeAnimation.cpp:
(WebCore::KeyframeAnimation::timeToNextService): isFallbackAnimating() -> !isAccelerated().
* rendering/RenderLayerBacking.cpp:
(WebCore::RenderLayerBacking::updateGraphicsLayerGeometry): Avoid touching the transform or
opacity if an accelerated animation is running.
* rendering/RenderLayerCompositor.cpp:
(WebCore::RenderLayerCompositor::requiresCompositingForAnimation): Make compositing layers
if an animation of transform or opacity is running.
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@63576 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
index 21613c9..d11129d 100644
--- a/LayoutTests/ChangeLog
+++ b/LayoutTests/ChangeLog
@@ -1,3 +1,16 @@
+2010-07-16 Simon Fraser <simon.fraser at apple.com>
+
+ Reviewed by Sam Weinig.
+
+ Safari pegs CPU and drops frames on http://neography.com/experiment/circles/solarsystem/ (CSS animations)
+ https://bugs.webkit.org/show_bug.cgi?id=41409
+
+ Test for creating compositing layers when running animations of transform, even on platforms that don't
+ run accelerated animations.
+
+ * compositing/animation/animation-compositing-expected.txt: Added.
+ * compositing/animation/animation-compositing.html: Added.
+
2010-07-16 Ojan Vafai <ojan at chromium.org>
Unreviewed. Put expected result from r63568 in the right place.
diff --git a/LayoutTests/compositing/animation/animation-compositing-expected.txt b/LayoutTests/compositing/animation/animation-compositing-expected.txt
new file mode 100644
index 0000000..c5a9795
--- /dev/null
+++ b/LayoutTests/compositing/animation/animation-compositing-expected.txt
@@ -0,0 +1 @@
+PASS: created compositing layers when animating transform.
diff --git a/LayoutTests/compositing/animation/animation-compositing.html b/LayoutTests/compositing/animation/animation-compositing.html
new file mode 100644
index 0000000..86f8dcd
--- /dev/null
+++ b/LayoutTests/compositing/animation/animation-compositing.html
@@ -0,0 +1,56 @@
+<!DOCTYPE html>
+
+<html>
+<head>
+ <style type="text/css" media="screen">
+ .box {
+ height: 100px;
+ width: 100px;
+ background-color: blue;
+ }
+
+ .spinning {
+ -webkit-animation: spin 2s infinite linear;
+ }
+
+ @-webkit-keyframes spin {
+ from { -webkit-transform: rotate(0); }
+ to { -webkit-transform: rotate(360deg); }
+ }
+ </style>
+ <script type="text/javascript" charset="utf-8">
+ if (window.layoutTestController) {
+ layoutTestController.dumpAsText();
+ layoutTestController.waitUntilDone();
+ }
+
+ function doTest()
+ {
+ var box = document.getElementById('box');
+ box.addEventListener('webkitAnimationStart', function() {
+ if (window.layoutTestController) {
+ var layers = layoutTestController.layerTreeAsText();
+ var result;
+ if (layers != "")
+ result = "PASS: created compositing layers when animating transform.";
+ else
+ result = "FAIL: no layers found";
+ document.getElementById('result').innerHTML = result;
+ layoutTestController.notifyDone();
+ }
+ }, false);
+ document.getElementById('box').className = 'spinning';
+ }
+
+ window.addEventListener('load', doTest, false);
+ </script>
+</head>
+<body>
+
+ <div id="box" class="box"></div>
+
+ <!-- We should create layers, even on platforms that don't support accelerated animation. -->
+ <div id="result">Test only works in DRT</div>
+
+</body>
+</html>
diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog
index f27a561..cb824cf 100644
--- a/WebCore/ChangeLog
+++ b/WebCore/ChangeLog
@@ -2,6 +2,62 @@
Reviewed by Sam Weinig.
+ Safari pegs CPU and drops frames on http://neography.com/experiment/circles/solarsystem/ (CSS animations)
+ https://bugs.webkit.org/show_bug.cgi?id=41409
+
+ AnimationController::isAnimatingPropertyOnRenderer() really asked whether an accelerated animation
+ or transition was running. This prevented us from falling into compositing layers for animation
+ on platforms, like Windows, that don't have accelerated animations.
+
+ Fix by making things more explicit: we now have two methods, isRunningAnimationOnRenderer()
+ and isRunningAcceleratedAnimationOnRenderer().
+
+ Changes are more extensive because I flipped the sense of 'm_fallbackAnimating', which is
+ now 'm_isAccelerated', for clarity.
+
+ Test: compositing/animation/animation-compositing.html
+
+ * page/animation/AnimationBase.cpp:
+ (WebCore::AnimationBase::AnimationBase): m_fallbackAnimating -> m_isAccelerated
+ (WebCore::AnimationBase::blendProperties): Ditto.
+ (WebCore::AnimationBase::updateStateMachine): Ditto.
+ * page/animation/AnimationBase.h:
+ (WebCore::AnimationBase::isAnimatingProperty): Takes new acceleratedOnly parameter
+ which causes the method to only return true if the animation is accelerated.
+ (WebCore::AnimationBase::isAccelerated): Changed from isFallbackAnimating.
+
+ * page/animation/AnimationController.cpp:
+ (WebCore::AnimationControllerPrivate::isRunningAnimationOnRenderer):
+ (WebCore::AnimationControllerPrivate::isRunningAcceleratedAnimationOnRenderer):
+ (WebCore::AnimationController::isRunningAnimationOnRenderer):
+ (WebCore::AnimationController::isRunningAcceleratedAnimationOnRenderer):
+
+ * page/animation/CompositeAnimation.h:
+ * page/animation/AnimationController.h: Rename isAnimatingPropertyOnRenderer(), add
+ isRunningAcceleratedAnimationOnRenderer().
+ * page/animation/AnimationControllerPrivate.h: Ditto.
+ * page/animation/CompositeAnimation.cpp:
+ (WebCore::CompositeAnimation::updateTransitions): !isFallbackAnimating() -> isAccelerated().
+ (WebCore::CompositeAnimation::isAnimatingProperty): Pass acceleratedOnly down.
+
+ * page/animation/ImplicitAnimation.cpp:
+ (WebCore::ImplicitAnimation::timeToNextService): !isFallbackAnimating() -> isAccelerated().
+
+ * page/animation/KeyframeAnimation.cpp:
+ (WebCore::KeyframeAnimation::timeToNextService): isFallbackAnimating() -> !isAccelerated().
+
+ * rendering/RenderLayerBacking.cpp:
+ (WebCore::RenderLayerBacking::updateGraphicsLayerGeometry): Avoid touching the transform or
+ opacity if an accelerated animation is running.
+
+ * rendering/RenderLayerCompositor.cpp:
+ (WebCore::RenderLayerCompositor::requiresCompositingForAnimation): Make compositing layers
+ if an animation of transform or opacity is running.
+
+2010-07-16 Simon Fraser <simon.fraser at apple.com>
+
+ Reviewed by Sam Weinig.
+
Assertion when turning Accelerated Compositing off on a composited page
https://bugs.webkit.org/show_bug.cgi?id=42408
diff --git a/WebCore/page/animation/AnimationBase.cpp b/WebCore/page/animation/AnimationBase.cpp
index 7195d1f..83fd039 100644
--- a/WebCore/page/animation/AnimationBase.cpp
+++ b/WebCore/page/animation/AnimationBase.cpp
@@ -774,7 +774,7 @@ AnimationBase::AnimationBase(const Animation* transition, RenderObject* renderer
, m_object(renderer)
, m_animation(const_cast<Animation*>(transition))
, m_compAnim(compAnim)
- , m_fallbackAnimating(false)
+ , m_isAccelerated(false)
, m_transformFunctionListValid(false)
, m_nextIterationDuration(-1)
, m_next(0)
@@ -837,7 +837,7 @@ bool AnimationBase::blendProperties(const AnimationBase* anim, int prop, RenderS
if (wrapper) {
wrapper->blend(anim, dst, a, b, progress);
#if USE(ACCELERATED_COMPOSITING)
- return !wrapper->animationIsAccelerated() || anim->isFallbackAnimating();
+ return !wrapper->animationIsAccelerated() || !anim->isAccelerated();
#else
return true;
#endif
@@ -974,7 +974,7 @@ void AnimationBase::updateStateMachine(AnimStateInput input, double param)
// We won't try to start accelerated animations if we are overridden and
// just move on to the next state.
m_animState = AnimationStateStartWaitResponse;
- m_fallbackAnimating = true;
+ m_isAccelerated = false;
updateStateMachine(AnimationStateInputStartTimeSet, beginAnimationUpdateTime());
}
else {
@@ -985,7 +985,7 @@ void AnimationBase::updateStateMachine(AnimStateInput input, double param)
bool started = startAnimation(timeOffset);
m_compAnim->animationController()->addToStartTimeResponseWaitList(this, started);
- m_fallbackAnimating = !started;
+ m_isAccelerated = started;
}
break;
case AnimationStateStartWaitResponse:
@@ -1108,11 +1108,11 @@ void AnimationBase::updateStateMachine(AnimStateInput input, double param)
// We won't try to start accelerated animations if we are overridden and
// just move on to the next state.
updateStateMachine(AnimationStateInputStartTimeSet, beginAnimationUpdateTime());
- m_fallbackAnimating = true;
+ m_isAccelerated = false;
} else {
bool started = startAnimation(beginAnimationUpdateTime() - m_startTime);
m_compAnim->animationController()->addToStartTimeResponseWaitList(this, started);
- m_fallbackAnimating = !started;
+ m_isAccelerated = started;
}
break;
case AnimationStateFillingForwards:
diff --git a/WebCore/page/animation/AnimationBase.h b/WebCore/page/animation/AnimationBase.h
index 91ef8cf..9bdca3a 100644
--- a/WebCore/page/animation/AnimationBase.h
+++ b/WebCore/page/animation/AnimationBase.h
@@ -144,9 +144,10 @@ public:
// Does this animation/transition involve the given property?
virtual bool affectsProperty(int /*property*/) const { return false; }
- bool isAnimatingProperty(int property, bool isRunningNow) const
+
+ bool isAnimatingProperty(int property, bool acceleratedOnly, bool isRunningNow) const
{
- if (m_fallbackAnimating)
+ if (acceleratedOnly && !m_isAccelerated)
return false;
if (isRunningNow)
@@ -197,7 +198,7 @@ protected:
void goIntoEndingOrLoopingState();
- bool isFallbackAnimating() const { return m_fallbackAnimating; }
+ bool isAccelerated() const { return m_isAccelerated; }
static bool propertiesEqual(int prop, const RenderStyle* a, const RenderStyle* b);
static int getPropertyAtIndex(int, bool& isShorthand);
@@ -220,7 +221,7 @@ protected:
RefPtr<Animation> m_animation;
CompositeAnimation* m_compAnim;
- bool m_fallbackAnimating; // true when animating an accelerated property but have to fall back to software
+ bool m_isAccelerated;
bool m_transformFunctionListValid;
double m_totalDuration, m_nextIterationDuration;
diff --git a/WebCore/page/animation/AnimationController.cpp b/WebCore/page/animation/AnimationController.cpp
index 3761c5a..b5d87e6 100644
--- a/WebCore/page/animation/AnimationController.cpp
+++ b/WebCore/page/animation/AnimationController.cpp
@@ -209,13 +209,22 @@ void AnimationControllerPrivate::animationTimerFired(Timer<AnimationControllerPr
fireEventsAndUpdateStyle();
}
-bool AnimationControllerPrivate::isAnimatingPropertyOnRenderer(RenderObject* renderer, CSSPropertyID property, bool isRunningNow) const
+bool AnimationControllerPrivate::isRunningAnimationOnRenderer(RenderObject* renderer, CSSPropertyID property, bool isRunningNow) const
{
RefPtr<CompositeAnimation> animation = m_compositeAnimations.get(renderer);
if (!animation)
return false;
- return animation->isAnimatingProperty(property, isRunningNow);
+ return animation->isAnimatingProperty(property, false, isRunningNow);
+}
+
+bool AnimationControllerPrivate::isRunningAcceleratedAnimationOnRenderer(RenderObject* renderer, CSSPropertyID property, bool isRunningNow) const
+{
+ RefPtr<CompositeAnimation> animation = m_compositeAnimations.get(renderer);
+ if (!animation)
+ return false;
+
+ return animation->isAnimatingProperty(property, true, isRunningNow);
}
void AnimationControllerPrivate::suspendAnimations(Document* document)
@@ -532,9 +541,14 @@ bool AnimationController::pauseTransitionAtTime(RenderObject* renderer, const St
return m_data->pauseTransitionAtTime(renderer, property, t);
}
-bool AnimationController::isAnimatingPropertyOnRenderer(RenderObject* renderer, CSSPropertyID property, bool isRunningNow) const
+bool AnimationController::isRunningAnimationOnRenderer(RenderObject* renderer, CSSPropertyID property, bool isRunningNow) const
+{
+ return m_data->isRunningAnimationOnRenderer(renderer, property, isRunningNow);
+}
+
+bool AnimationController::isRunningAcceleratedAnimationOnRenderer(RenderObject* renderer, CSSPropertyID property, bool isRunningNow) const
{
- return m_data->isAnimatingPropertyOnRenderer(renderer, property, isRunningNow);
+ return m_data->isRunningAcceleratedAnimationOnRenderer(renderer, property, isRunningNow);
}
void AnimationController::suspendAnimations(Document* document)
diff --git a/WebCore/page/animation/AnimationController.h b/WebCore/page/animation/AnimationController.h
index db82618..d184b45 100644
--- a/WebCore/page/animation/AnimationController.h
+++ b/WebCore/page/animation/AnimationController.h
@@ -61,7 +61,8 @@ public:
bool pauseTransitionAtTime(RenderObject*, const String& property, double t); // To be used only for testing
unsigned numberOfActiveAnimations() const; // To be used only for testing
- bool isAnimatingPropertyOnRenderer(RenderObject*, CSSPropertyID, bool isRunningNow = true) const;
+ bool isRunningAnimationOnRenderer(RenderObject*, CSSPropertyID, bool isRunningNow = true) const;
+ bool isRunningAcceleratedAnimationOnRenderer(RenderObject*, CSSPropertyID, bool isRunningNow = true) const;
void suspendAnimations(Document*);
void resumeAnimations(Document*);
diff --git a/WebCore/page/animation/AnimationControllerPrivate.h b/WebCore/page/animation/AnimationControllerPrivate.h
index 5ef9098..3ae15a5 100644
--- a/WebCore/page/animation/AnimationControllerPrivate.h
+++ b/WebCore/page/animation/AnimationControllerPrivate.h
@@ -70,7 +70,8 @@ public:
void suspendAnimations(Document*);
void resumeAnimations(Document*);
- bool isAnimatingPropertyOnRenderer(RenderObject*, CSSPropertyID, bool isRunningNow) const;
+ bool isRunningAnimationOnRenderer(RenderObject*, CSSPropertyID, bool isRunningNow) const;
+ bool isRunningAcceleratedAnimationOnRenderer(RenderObject*, CSSPropertyID, bool isRunningNow) const;
bool pauseAnimationAtTime(RenderObject*, const String& name, double t);
bool pauseTransitionAtTime(RenderObject*, const String& property, double t);
diff --git a/WebCore/page/animation/CompositeAnimation.cpp b/WebCore/page/animation/CompositeAnimation.cpp
index 7619b1f..57c2aa4 100644
--- a/WebCore/page/animation/CompositeAnimation.cpp
+++ b/WebCore/page/animation/CompositeAnimation.cpp
@@ -136,7 +136,7 @@ void CompositeAnimation::updateTransitions(RenderObject* renderer, RenderStyle*
#if USE(ACCELERATED_COMPOSITING)
// For accelerated animations we need to return a new RenderStyle with the _current_ value
// of the property, so that restarted transitions use the correct starting point.
- if (AnimationBase::animationOfPropertyIsAccelerated(prop) && !implAnim->isFallbackAnimating()) {
+ if (AnimationBase::animationOfPropertyIsAccelerated(prop) && implAnim->isAccelerated()) {
if (!modifiedCurrentStyle)
modifiedCurrentStyle = RenderStyle::clone(currentStyle);
@@ -460,14 +460,14 @@ void CompositeAnimation::resumeOverriddenImplicitAnimations(int property)
}
}
-bool CompositeAnimation::isAnimatingProperty(int property, bool isRunningNow) const
+bool CompositeAnimation::isAnimatingProperty(int property, bool acceleratedOnly, bool isRunningNow) const
{
if (!m_keyframeAnimations.isEmpty()) {
m_keyframeAnimations.checkConsistency();
AnimationNameMap::const_iterator animationsEnd = m_keyframeAnimations.end();
for (AnimationNameMap::const_iterator it = m_keyframeAnimations.begin(); it != animationsEnd; ++it) {
KeyframeAnimation* anim = it->second.get();
- if (anim && anim->isAnimatingProperty(property, isRunningNow))
+ if (anim && anim->isAnimatingProperty(property, acceleratedOnly, isRunningNow))
return true;
}
}
@@ -476,7 +476,7 @@ bool CompositeAnimation::isAnimatingProperty(int property, bool isRunningNow) co
CSSPropertyTransitionsMap::const_iterator transitionsEnd = m_transitions.end();
for (CSSPropertyTransitionsMap::const_iterator it = m_transitions.begin(); it != transitionsEnd; ++it) {
ImplicitAnimation* anim = it->second.get();
- if (anim && anim->isAnimatingProperty(property, isRunningNow))
+ if (anim && anim->isAnimatingProperty(property, acceleratedOnly, isRunningNow))
return true;
}
}
diff --git a/WebCore/page/animation/CompositeAnimation.h b/WebCore/page/animation/CompositeAnimation.h
index b7db442..51ba565 100644
--- a/WebCore/page/animation/CompositeAnimation.h
+++ b/WebCore/page/animation/CompositeAnimation.h
@@ -70,8 +70,8 @@ public:
bool hasAnimations() const { return !m_transitions.isEmpty() || !m_keyframeAnimations.isEmpty(); }
void setAnimating(bool);
- bool isAnimatingProperty(int property, bool isRunningNow) const;
-
+ bool isAnimatingProperty(int property, bool acceleratedOnly, bool isRunningNow) const;
+
PassRefPtr<KeyframeAnimation> getAnimationForProperty(int property) const;
void overrideImplicitAnimations(int property);
diff --git a/WebCore/page/animation/ImplicitAnimation.cpp b/WebCore/page/animation/ImplicitAnimation.cpp
index 328fe0e..da0a810 100644
--- a/WebCore/page/animation/ImplicitAnimation.cpp
+++ b/WebCore/page/animation/ImplicitAnimation.cpp
@@ -273,7 +273,7 @@ double ImplicitAnimation::timeToNextService()
// A return value of 0 means we need service. But if this is an accelerated animation we
// only need service at the end of the transition.
- if (animationOfPropertyIsAccelerated(m_animatingProperty) && !isFallbackAnimating()) {
+ if (animationOfPropertyIsAccelerated(m_animatingProperty) && isAccelerated()) {
bool isLooping;
getTimeToNextEvent(t, isLooping);
}
diff --git a/WebCore/page/animation/KeyframeAnimation.cpp b/WebCore/page/animation/KeyframeAnimation.cpp
index 4c2cbc8..2f2cfc0 100644
--- a/WebCore/page/animation/KeyframeAnimation.cpp
+++ b/WebCore/page/animation/KeyframeAnimation.cpp
@@ -400,7 +400,7 @@ double KeyframeAnimation::timeToNextService()
bool acceleratedPropertiesOnly = true;
for (HashSet<int>::const_iterator it = m_keyframes.beginProperties(); it != endProperties; ++it) {
- if (!animationOfPropertyIsAccelerated(*it) || isFallbackAnimating()) {
+ if (!animationOfPropertyIsAccelerated(*it) || !isAccelerated()) {
acceleratedPropertiesOnly = false;
break;
}
diff --git a/WebCore/rendering/RenderLayerBacking.cpp b/WebCore/rendering/RenderLayerBacking.cpp
index ed42a96..2ce9b9d 100644
--- a/WebCore/rendering/RenderLayerBacking.cpp
+++ b/WebCore/rendering/RenderLayerBacking.cpp
@@ -306,11 +306,11 @@ void RenderLayerBacking::updateGraphicsLayerGeometry()
// 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()->isAnimatingPropertyOnRenderer(renderer(), CSSPropertyWebkitTransform))
+ if (!renderer()->animation()->isRunningAcceleratedAnimationOnRenderer(renderer(), CSSPropertyWebkitTransform))
updateLayerTransform(renderer()->style());
// Set opacity, if it is not animating.
- if (!renderer()->animation()->isAnimatingPropertyOnRenderer(renderer(), CSSPropertyOpacity))
+ if (!renderer()->animation()->isRunningAcceleratedAnimationOnRenderer(renderer(), CSSPropertyOpacity))
updateLayerOpacity(renderer()->style());
RenderStyle* style = renderer()->style();
diff --git a/WebCore/rendering/RenderLayerCompositor.cpp b/WebCore/rendering/RenderLayerCompositor.cpp
index 36aa570..234ad7f 100644
--- a/WebCore/rendering/RenderLayerCompositor.cpp
+++ b/WebCore/rendering/RenderLayerCompositor.cpp
@@ -1240,8 +1240,8 @@ bool RenderLayerCompositor::requiresCompositingForIFrame(RenderObject* renderer)
bool RenderLayerCompositor::requiresCompositingForAnimation(RenderObject* renderer) const
{
if (AnimationController* animController = renderer->animation()) {
- return (animController->isAnimatingPropertyOnRenderer(renderer, CSSPropertyOpacity) && inCompositingMode())
- || animController->isAnimatingPropertyOnRenderer(renderer, CSSPropertyWebkitTransform);
+ return (animController->isRunningAnimationOnRenderer(renderer, CSSPropertyOpacity) && inCompositingMode())
+ || animController->isRunningAnimationOnRenderer(renderer, CSSPropertyWebkitTransform);
}
return false;
}
--
WebKit Debian packaging
More information about the Pkg-webkit-commits
mailing list