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_anchorPointZ(0)
     , m_isContainerForFixedPositionLayers(false)
     , m_fixedToContainerLayer(false)
     , m_isDrawable(false)
     , m_masksToBounds(false)
     , m_contentsOpaque(false)
     , m_doubleSided(true)
     , m_useLCDText(false)
     , m_preserves3D(false)
     , m_useParentBackfaceVisibility(false)
     , m_drawCheckerboardForMissingTiles(false)
     , m_forceRenderSurface(false)
     , m_replicaLayer(0)
     , 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 12 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();
 }
 
 void Layer::setNeedsFullTreeSync()
 {
@@ skipping 234 matching lines @@
         LayerTreeHost::setNeedsFilterContext(true);
 }
 
 bool Layer::needsDisplay() const
 {
     return m_needsDisplay;
 }
 
 void Layer::setOpacity(float opacity)
 {
-    if (m_opacity == opacity)
+    if (!m_layerAnimationController->setOpacity(opacity))
         return;
-    m_opacity = opacity;
     setNeedsCommit();
 }
 
+float Layer::opacity() const
+{
+    return m_layerAnimationController->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 11 matching lines @@
 void Layer::setSublayerTransform(const gfx::Transform& sublayerTransform)
 {
     if (m_sublayerTransform == sublayerTransform)
         return;
     m_sublayerTransform = sublayerTransform;
     setNeedsCommit();
 }
 
 void Layer::setTransform(const gfx::Transform& transform)
 {
-    if (m_transform == transform)
+    if (!m_layerAnimationController->setTransform(transform))
         return;
-    m_transform = transform;
     setNeedsCommit();
 }
 
+const gfx::Transform& Layer::transform() const
+{
+    return m_layerAnimationController->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 162 matching lines @@
     // arbitrarily large depending on page content, so we only push the property if it's changed.
     if (m_nonFastScrollableRegionChanged) {
         layer->setNonFastScrollableRegion(m_nonFastScrollableRegion);
         m_nonFastScrollableRegionChanged = false;
     }
     if (m_touchEventHandlerRegionChanged) {
         layer->setTouchEventHandlerRegion(m_touchEventHandlerRegion);
         m_touchEventHandlerRegionChanged = false;
     }
     layer->setContentsOpaque(m_contentsOpaque);
-    if (!opacityIsAnimating())
-        layer->setOpacity(m_opacity);
     layer->setPosition(m_position);
     layer->setIsContainerForFixedPositionLayers(m_isContainerForFixedPositionLayers);
     layer->setFixedToContainerLayer(m_fixedToContainerLayer);
     layer->setPreserves3D(preserves3D());
     layer->setUseParentBackfaceVisibility(m_useParentBackfaceVisibility);
     layer->setScrollOffset(m_scrollOffset);
     layer->setMaxScrollOffset(m_maxScrollOffset);
     layer->setSublayerTransform(m_sublayerTransform);
-    if (!transformIsAnimating())
-        layer->setTransform(m_transform);
 
     // If the main thread commits multiple times before the impl thread actually draws, then damage tracking
     // will become incorrect if we simply clobber the updateRect here. The LayerImpl's updateRect needs to
     // accumulate (i.e. union) any update changes that have occurred on the main thread.
     m_updateRect.Union(layer->updateRect());
     layer->setUpdateRect(m_updateRect);
 
     layer->setScrollDelta(layer->scrollDelta() - layer->sentScrollDelta());
     layer->setSentScrollDelta(gfx::Vector2d());
 
@@ skipping 103 matching lines @@
             return result;
     }
     return result;
 }
 
 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());
+    m_layerAnimationController->setTransform(toReturn->transform());
+    m_layerAnimationController->setOpacity(toReturn->opacity());
+    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