Use an auxiliary list of animation controllers.

cc/layer.cc

 // Copyright 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layer.h"
 
 #include "cc/active_animation.h"
 #include "cc/animation_events.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_impl.h"
@@ skipping 14 matching lines @@
 {
     return make_scoped_refptr(new Layer());
 }
 
 Layer::Layer()
     : m_needsDisplay(false)
     , m_stackingOrderChanged(false)
     , m_layerId(s_nextLayerId++)
     , m_parent(0)
     , m_layerTreeHost(0)
-    , m_layerAnimationController(LayerAnimationController::create(this))
+    , m_layerAnimationController(LayerAnimationController::create())
     , m_scrollable(false)
     , m_shouldScrollOnMainThread(false)
     , m_haveWheelEventHandlers(false)
     , m_nonFastScrollableRegionChanged(false)
     , m_touchEventHandlerRegionChanged(false)
     , m_anchorPoint(0.5, 0.5)
     , m_backgroundColor(0)
     , m_opacity(1.0)
     , m_filter(0)
     , m_anchorPointZ(0)
@@ skipping 18 matching lines @@
     , m_rasterScale(1.0)
     , m_automaticallyComputeRasterScale(false)
     , m_boundsContainPageScale(false)
     , m_layerAnimationDelegate(0)
     , m_layerScrollClient(0)
 {
     if (m_layerId < 0) {
         s_nextLayerId = 1;
         m_layerId = s_nextLayerId++;
     }
+    m_layerAnimationController->setId(m_layerId);
 }
 
 Layer::~Layer()
 {
     // Our parent should be holding a reference to us so there should be no
     // way for us to be destroyed while we still have a parent.
     DCHECK(!parent());
 
     // Remove the parent reference from all children.
     removeAllChildren();
@@ skipping 14 matching lines @@
     m_layerTreeHost = host;
 
     for (size_t i = 0; i < m_children.size(); ++i)
         m_children[i]->setLayerTreeHost(host);
 
     if (m_maskLayer)
         m_maskLayer->setLayerTreeHost(host);
     if (m_replicaLayer)
         m_replicaLayer->setLayerTreeHost(host);
 
-    // If this layer already has active animations, the host needs to be notified.
-    if (host && m_layerAnimationController->hasActiveAnimation())
-        host->didAddAnimation();
+    m_layerAnimationController->setAnimationRegistrar(host);
 }
 
 void Layer::setNeedsCommit()
 {
     if (m_layerTreeHost)
         m_layerTreeHost->setNeedsCommit();
 }
 
 gfx::Rect Layer::layerRectToContentRect(const gfx::RectF& layerRect) const
 {
@@ skipping 231 matching lines @@
 bool Layer::needsDisplay() const
 {
     return m_needsDisplay;
 }
 
 void Layer::setOpacity(float opacity)
 {
     if (m_opacity == opacity)
         return;
     m_opacity = opacity;
+    m_opacityLastUpdateTime = base::TimeTicks::Now();
     setNeedsCommit();
 }
 
+float Layer::opacity() const
+{
+    if (m_layerAnimationController->opacityLastUpdateTime() > m_opacityLastUpdateTime)

[jamesr, 2012/12/03 04:40:15]

could you explain what this logic is for? anything that's timestamp based seems
very race-prone

[Ian Vollick, 2012/12/03 14:47:03]

Sure. Animation controllers used to push new values to their layers. This was
racey as well, in that whichever party modified a layer last (either WebCore or
an animation controller) clobbered the value. Now that we're going to be sharing
controllers between LayerImpls, I've switched to a pull model. To replicate the
old behavior, layers return whichever value is fresher (either the value from
WebCore or the animation controller's). I use timestamps to make this
determination.

[enne (OOO), 2012/12/04 01:32:16]

This is really strange to my eyes too.  If the opacity is animating, shouldn't
that control the opacity no matter what?  What does it mean to manually set the
opacity on something that's also being animated?

[Ian Vollick, 2012/12/04 19:49:06]

Yes, it should. In fact, in my latest patch we explicitly ignore transform and
opacity updates if the values are animating. The problem these timestamps were
trying to address was not how to deal with setFoo when foo was animating, but
how a layer can decide which foo (it's own copy, or the animator's) was fresher
after an animation had completed, since it had no way of knowing which came
last, the animation or the call to setFoo.

The newest patch simplifies the situation by making the animation controller the
manager of its layer's opacity and transform. This has a number of benefits. It
saves space -- we no longer have to have redundant copies of the transform and
opacity lying around. It also encapsulates the logic for dealing with setFoo
when foo is animating nicely within the animator. Since the animator has all the
knowledge it needs to determine if the animated or set value is fresher, there
is no longer a need for timestamps/sequence #'s, etc. It also simplifies logic
in the layer classes. When a layer is asked to set opacity, it just passes it
along to its animation controller. When it's asked for this value, it just
passes back the value from its controller.

+        return m_layerAnimationController->opacity();
+    return m_opacity;
+}
+
 bool Layer::opacityIsAnimating() const
 {
     return m_layerAnimationController->isAnimatingProperty(ActiveAnimation::Opacity);
 }
 
 void Layer::setContentsOpaque(bool opaque)
 {
     if (m_contentsOpaque == opaque)
         return;
     m_contentsOpaque = opaque;
@@ skipping 14 matching lines @@
         return;
     m_sublayerTransform = sublayerTransform;
     setNeedsCommit();
 }
 
 void Layer::setTransform(const gfx::Transform& transform)
 {
     if (m_transform == transform)
         return;
     m_transform = transform;
+    m_transformLastUpdateTime = base::TimeTicks::Now();
     setNeedsCommit();
 }
 
+const gfx::Transform& Layer::transform() const
+{
+    if (m_layerAnimationController->transformLastUpdateTime() > m_transformLastUpdateTime)
+        return m_layerAnimationController->transform();
+    return m_transform;
+}
+
 bool Layer::transformIsAnimating() const
 {
     return m_layerAnimationController->isAnimatingProperty(ActiveAnimation::Transform);
 }
 
 void Layer::setScrollOffset(gfx::Vector2d scrollOffset)
 {
     if (m_scrollOffset == scrollOffset)
         return;
     m_scrollOffset = scrollOffset;
@@ skipping 293 matching lines @@
             return true;
     }
     return false;
 }
 
 int Layer::id() const
 {
     return m_layerId;
 }
 
-float Layer::opacity() const
-{
-    return m_opacity;
-}
-
-void Layer::setOpacityFromAnimation(float opacity)
-{
-    // This is called due to an ongoing accelerated animation. Since this animation is
-    // also being run on the impl thread, there is no need to request a commit to push
-    // this value over, so set the value directly rather than calling setOpacity.
-    m_opacity = opacity;
-}
-
-const gfx::Transform& Layer::transform() const
-{
-    return m_transform;
-}
-
-void Layer::setTransformFromAnimation(const gfx::Transform& transform)
-{
-    // This is called due to an ongoing accelerated animation. Since this animation is
-    // also being run on the impl thread, there is no need to request a commit to push
-    // this value over, so set this value directly rather than calling setTransform.
-    m_transform = transform;
-}
-
 bool Layer::addAnimation(scoped_ptr <ActiveAnimation> animation)
 {
     // WebCore currently assumes that accelerated animations will start soon
     // after the animation is added. However we cannot guarantee that if we do
     // not have a layerTreeHost that will setNeedsCommit().
     // Unfortunately, the fix below to guarantee correctness causes performance
     // regressions on Android, since Android has shipped for a long time
     // with all animations accelerated. For this reason, we will live with
     // this bug only on Android until the bug is fixed.
     // http://crbug.com/129683
 #if !defined(OS_ANDROID)
     if (!m_layerTreeHost)
         return false;
 
     if (!m_layerTreeHost->settings().acceleratedAnimationEnabled)
         return false;
 #endif
 
     m_layerAnimationController->addAnimation(animation.Pass());
-    if (m_layerTreeHost) {
-        m_layerTreeHost->didAddAnimation();
         setNeedsCommit();
-    }
     return true;
 }
 
 void Layer::pauseAnimation(int animationId, double timeOffset)
 {
     m_layerAnimationController->pauseAnimation(animationId, timeOffset);
     setNeedsCommit();
 }
 
 void Layer::removeAnimation(int animationId)
 {
     m_layerAnimationController->removeAnimation(animationId);
     setNeedsCommit();
 }
 
 void Layer::suspendAnimations(double monotonicTime)
 {
     m_layerAnimationController->suspendAnimations(monotonicTime);
     setNeedsCommit();
 }
 
 void Layer::resumeAnimations(double monotonicTime)
 {
     m_layerAnimationController->resumeAnimations(monotonicTime);
     setNeedsCommit();
 }
 
-void Layer::setLayerAnimationController(scoped_ptr<LayerAnimationController> layerAnimationController)
+void Layer::setLayerAnimationController(scoped_refptr<LayerAnimationController> layerAnimationController)
 {
-    m_layerAnimationController = layerAnimationController.Pass();
+    m_layerAnimationController = layerAnimationController;
     if (m_layerAnimationController) {
-        m_layerAnimationController->setClient(this);
+        m_layerAnimationController->setId(id());
         m_layerAnimationController->setForceSync();
     }
     setNeedsCommit();
 }
 
-scoped_ptr<LayerAnimationController> Layer::releaseLayerAnimationController()
+scoped_refptr<LayerAnimationController> Layer::releaseLayerAnimationController()
 {
-    scoped_ptr<LayerAnimationController> toReturn = m_layerAnimationController.Pass();
-    m_layerAnimationController = LayerAnimationController::create(this);
-    return toReturn.Pass();
+    scoped_refptr<LayerAnimationController> toReturn = m_layerAnimationController;
+    m_layerAnimationController = LayerAnimationController::create();
+    m_layerAnimationController->setId(id());
+    return toReturn;
 }
 
 bool Layer::hasActiveAnimation() const
 {
     return m_layerAnimationController->hasActiveAnimation();
 }
 
 void Layer::notifyAnimationStarted(const AnimationEvent& event, double wallClockTime)
 {
     m_layerAnimationController->notifyAnimationStarted(event);
@@ skipping 18 matching lines @@
 {
     return 0;
 }
 
 void sortLayers(std::vector<scoped_refptr<Layer> >::iterator, std::vector<scoped_refptr<Layer> >::iterator, void*)
 {
     // Currently we don't use z-order to decide what to paint, so there's no need to actually sort Layers.
 }
 
 }  // namespace cc