Ref count layer 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_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)
@@ skipping 11 matching lines @@
     , m_automaticallyComputeRasterScale(false)
     , m_boundsContainPageScale(false)
     , m_layerAnimationDelegate(0)
     , m_layerScrollClient(0)
 {
     if (m_layerId < 0) {
         s_nextLayerId = 1;
         m_layerId = s_nextLayerId++;
     }
 
-    addLayerAnimationObserver(m_layerAnimationController.get());
+    m_layerAnimationController = LayerAnimationController::create(m_layerId);
+    m_layerAnimationController->addObserver(this);
+    addLayerAnimationEventObserver(m_layerAnimationController.get());
 }
 
 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());
 
+    m_layerAnimationController->removeObserver(this);
+
     // Remove the parent reference from all children.
     removeAllChildren();
 }
 
 void Layer::setLayerTreeHost(LayerTreeHost* host)
 {
     if (m_layerTreeHost == host)
         return;
 
     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 ? host->animationRegistrar() : 0);
+
+    if (host && m_layerAnimationController->hasAnyAnimation())
+        host->setNeedsCommit();
 }
 
 void Layer::setNeedsCommit()
 {
     if (m_layerTreeHost)
         m_layerTreeHost->setNeedsCommit();
 }
 
 void Layer::setNeedsFullTreeSync()
 {
@@ skipping 258 matching lines @@
 }
 
 void Layer::setOpacity(float opacity)
 {
     if (m_opacity == opacity)
         return;
     m_opacity = opacity;
     setNeedsCommit();
 }
 
+float Layer::opacity() const
+{
+    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 17 matching lines @@
 }
 
 void Layer::setTransform(const gfx::Transform& transform)
 {
     if (m_transform == transform)
         return;
     m_transform = transform;
     setNeedsCommit();
 }
 
+const gfx::Transform& Layer::transform() const
+{
+    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 273 matching lines @@
     DCHECK(!m_drawProperties.render_surface);
     m_drawProperties.render_surface = make_scoped_ptr(new RenderSurface(this));
     m_drawProperties.render_target = this;
 }
 
 int Layer::id() const
 {
     return m_layerId;
 }
 
-float Layer::opacity() const
-{
-    return m_opacity;
-}
-
-void Layer::setOpacityFromAnimation(float opacity)
+void Layer::OnOpacityAnimated(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)
+void Layer::OnTransformAnimated(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();
-    }
+    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)
 {
-    if (m_layerAnimationController)
-        removeLayerAnimationObserver(m_layerAnimationController.get());
-
-    m_layerAnimationController = layerAnimationController.Pass();
-    if (m_layerAnimationController) {
-        m_layerAnimationController->setClient(this);
-        m_layerAnimationController->setForceSync();
-        addLayerAnimationObserver(m_layerAnimationController.get());
-    }
+    removeLayerAnimationEventObserver(m_layerAnimationController.get());
+    m_layerAnimationController->removeObserver(this);
+    m_layerAnimationController = layerAnimationController;
+    m_layerAnimationController->setForceSync();
+    m_layerAnimationController->addObserver(this);
+    addLayerAnimationEventObserver(m_layerAnimationController.get());
     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();
+    m_layerAnimationController->removeObserver(this);
+    scoped_refptr<LayerAnimationController> toReturn = m_layerAnimationController;
+    m_layerAnimationController = LayerAnimationController::create(id());
+    m_layerAnimationController->addObserver(this);
+    return toReturn;
 }
 
 bool Layer::hasActiveAnimation() const
 {
     return m_layerAnimationController->hasActiveAnimation();
 }
 
 void Layer::notifyAnimationStarted(const AnimationEvent& event, double wallClockTime)
 {
-    FOR_EACH_OBSERVER(LayerAnimationObserver, m_layerAnimationObservers,
+    FOR_EACH_OBSERVER(LayerAnimationEventObserver, m_layerAnimationObservers,
                       OnAnimationStarted(event));
     if (m_layerAnimationDelegate)
         m_layerAnimationDelegate->notifyAnimationStarted(wallClockTime);
 }
 
 void Layer::notifyAnimationFinished(double wallClockTime)
 {
     if (m_layerAnimationDelegate)
         m_layerAnimationDelegate->notifyAnimationFinished(wallClockTime);
 }
 
-void Layer::addLayerAnimationObserver(LayerAnimationObserver* animationObserver)
+void Layer::addLayerAnimationEventObserver(LayerAnimationEventObserver* animationObserver)
 {
     if (!m_layerAnimationObservers.HasObserver(animationObserver))
         m_layerAnimationObservers.AddObserver(animationObserver);
 }
 
-void Layer::removeLayerAnimationObserver(LayerAnimationObserver* animationObserver)
+void Layer::removeLayerAnimationEventObserver(LayerAnimationEventObserver* animationObserver)
 {
     m_layerAnimationObservers.RemoveObserver(animationObserver);
 }
 
 Region Layer::visibleContentOpaqueRegion() const
 {
     if (contentsOpaque())
         return visibleContentRect();
     return Region();
 }
 
 ScrollbarLayer* Layer::toScrollbarLayer()
 {
     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