Use an auxiliary list of animation controllers.

cc/layer_animation_controller.cc

 // Copyright 2012 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_animation_controller.h"
 
 #include "cc/active_animation.h"
+#include "cc/animation_registrar.h"
 #include "cc/keyframed_animation_curve.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
-LayerAnimationController::LayerAnimationController(LayerAnimationControllerClient* client)
+LayerAnimationController::LayerAnimationController()
     : m_forceSync(false)
-    , m_client(client)
+    , m_id(-1)
+    , m_registrar(0)
 {
 }
 
 LayerAnimationController::~LayerAnimationController()
 {
+    if (m_registrar)
+        m_registrar->Unregister(this);
 }
 
-scoped_ptr<LayerAnimationController> LayerAnimationController::create(LayerAnimationControllerClient* client)
+scoped_refptr<LayerAnimationController> LayerAnimationController::create()
 {
-    return make_scoped_ptr(new LayerAnimationController(client));
+    return make_scoped_refptr(new LayerAnimationController());
 }
 
 void LayerAnimationController::pauseAnimation(int animationId, double timeOffset)
 {
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
         if (m_activeAnimations[i]->id() == animationId)
             m_activeAnimations[i]->setRunState(ActiveAnimation::Paused, timeOffset + m_activeAnimations[i]->startTime());
     }
 }
 
 void LayerAnimationController::removeAnimation(int animationId)
 {
     for (size_t i = 0; i < m_activeAnimations.size();) {
         if (m_activeAnimations[i]->id() == animationId)
             m_activeAnimations.remove(i);
         else
             i++;
     }
+    updateRegistration();
 }
 
 void LayerAnimationController::removeAnimation(int animationId, ActiveAnimation::TargetProperty targetProperty)
 {
     for (size_t i = 0; i < m_activeAnimations.size();) {
         if (m_activeAnimations[i]->id() == animationId && m_activeAnimations[i]->targetProperty() == targetProperty)
             m_activeAnimations.remove(i);
         else
             i++;
     }
+    updateRegistration();
 }
 
 // According to render layer backing, these are for testing only.
 void LayerAnimationController::suspendAnimations(double monotonicTime)
 {
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
         if (!m_activeAnimations[i]->isFinished())
             m_activeAnimations[i]->setRunState(ActiveAnimation::Paused, monotonicTime);
     }
 }
@@ skipping 29 matching lines @@
 
 void LayerAnimationController::animate(double monotonicTime, AnimationEventsVector* events)
 {
     startAnimationsWaitingForNextTick(monotonicTime, events);
     startAnimationsWaitingForStartTime(monotonicTime, events);
     startAnimationsWaitingForTargetAvailability(monotonicTime, events);
     resolveConflicts(monotonicTime);
     tickAnimations(monotonicTime);
     markAnimationsForDeletion(monotonicTime, events);
     startAnimationsWaitingForTargetAvailability(monotonicTime, events);
+
+    updateRegistration();
 }
 
 void LayerAnimationController::addAnimation(scoped_ptr<ActiveAnimation> animation)
 {
     m_activeAnimations.append(animation.Pass());
+    updateRegistration();
 }
 
 ActiveAnimation* LayerAnimationController::getActiveAnimation(int groupId, ActiveAnimation::TargetProperty targetProperty) const
 {
     for (size_t i = 0; i < m_activeAnimations.size(); ++i)
         if (m_activeAnimations[i]->group() == groupId && m_activeAnimations[i]->targetProperty() == targetProperty)
             return m_activeAnimations[i];
     return 0;
 }
 
@@ skipping 29 matching lines @@
 {
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
         if (m_activeAnimations[i]->group() == event.groupId && m_activeAnimations[i]->targetProperty() == event.targetProperty && m_activeAnimations[i]->needsSynchronizedStartTime()) {
             m_activeAnimations[i]->setNeedsSynchronizedStartTime(false);
             m_activeAnimations[i]->setStartTime(event.monotonicTime);
             return;
         }
     }
 }
 
-void LayerAnimationController::setClient(LayerAnimationControllerClient* client)
+void LayerAnimationController::setAnimationRegistrar(AnimationRegistrar* registrar)
 {
-    m_client = client;
+    if (m_registrar == registrar)
+        return;

[nduca, 2012/12/04 05:51:13]

Oh i get it nao. Thanks.

Can we split out registration from activation? E.g. you're always registered and
then when your activation state changes, you just tell the registrar that you're
on or off at a given moment.

Also, Registrar->AnimationController? It sorta makes sense if you think of it...

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

Naming is hard. Perhaps registration is the wrong word for the concept I'm
trying to articulate here. What I mean by register is
register-as-an-active-animating-controller. Perhaps the two registrar functions
could be named Activate/Deactivate rather than Register/Unregister.

I don't think that splitting out these two concepts makes sense. As I understand
your comment, you take 'registered with' to mean 'associated with'. That
association is implied by having a non-null registrar pointer in
LayerAnimationController. The only idea I care about here is activation and
deactivation of controllers. Rather than splitting out registration from
activation, I think we should just rename registration to something that more
clearly means what I originally intended.
I like this, but if we made this change, I think we should also
LayerAnimationController -> LayerAnimator. What do you think? If we make this
switch, I'd like to do it in a second, brain-dead, sed patch so that it doesn't
hide the 'real' changes in this CL.

+
+    if (m_registrar && registrar)
+        m_registrar->Unregister(this);
+
+    m_registrar = registrar;
+
+    updateRegistration();
+}
+
+void LayerAnimationController::setId(int id)
+{
+    m_id = id;
 }
 
 void LayerAnimationController::pushNewAnimationsToImplThread(LayerAnimationController* controllerImpl) const
 {
     // Any new animations owned by the main thread's controller are cloned and adde to the impl thread's controller.
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
         // If the animation is already running on the impl thread, there is no need to copy it over.
         if (controllerImpl->getActiveAnimation(m_activeAnimations[i]->group(), m_activeAnimations[i]->targetProperty()))
             continue;
 
@@ skipping 37 matching lines @@
 }
 
 void LayerAnimationController::startAnimationsWaitingForNextTick(double monotonicTime, AnimationEventsVector* events)
 {
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
         if (m_activeAnimations[i]->runState() == ActiveAnimation::WaitingForNextTick) {
             m_activeAnimations[i]->setRunState(ActiveAnimation::Running, monotonicTime);
             if (!m_activeAnimations[i]->hasSetStartTime())
                 m_activeAnimations[i]->setStartTime(monotonicTime);
             if (events)
-                events->push_back(AnimationEvent(AnimationEvent::Started, m_client->id(), m_activeAnimations[i]->group(), m_activeAnimations[i]->targetProperty(), monotonicTime));
+                events->push_back(AnimationEvent(AnimationEvent::Started, m_id, m_activeAnimations[i]->group(), m_activeAnimations[i]->targetProperty(), monotonicTime));
         }
     }
 }
 
 void LayerAnimationController::startAnimationsWaitingForStartTime(double monotonicTime, AnimationEventsVector* events)
 {
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
         if (m_activeAnimations[i]->runState() == ActiveAnimation::WaitingForStartTime && m_activeAnimations[i]->startTime() <= monotonicTime) {
             m_activeAnimations[i]->setRunState(ActiveAnimation::Running, monotonicTime);
             if (events)
-                events->push_back(AnimationEvent(AnimationEvent::Started, m_client->id(), m_activeAnimations[i]->group(), m_activeAnimations[i]->targetProperty(), monotonicTime));
+                events->push_back(AnimationEvent(AnimationEvent::Started, m_id, m_activeAnimations[i]->group(), m_activeAnimations[i]->targetProperty(), monotonicTime));
         }
     }
 }
 
 void LayerAnimationController::startAnimationsWaitingForTargetAvailability(double monotonicTime, AnimationEventsVector* events)
 {
     // First collect running properties.
     TargetProperties blockedProperties;
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
         if (m_activeAnimations[i]->runState() == ActiveAnimation::Running || m_activeAnimations[i]->runState() == ActiveAnimation::Finished)
@@ skipping 18 matching lines @@
                 if (!blockedProperties.insert(*pIter).second)
                     nullIntersection = false;
             }
 
             // If the intersection is null, then we are free to start the animations in the group.
             if (nullIntersection) {
                 m_activeAnimations[i]->setRunState(ActiveAnimation::Running, monotonicTime);
                 if (!m_activeAnimations[i]->hasSetStartTime())
                     m_activeAnimations[i]->setStartTime(monotonicTime);
                 if (events)
-                    events->push_back(AnimationEvent(AnimationEvent::Started, m_client->id(), m_activeAnimations[i]->group(), m_activeAnimations[i]->targetProperty(), monotonicTime));
+                    events->push_back(AnimationEvent(AnimationEvent::Started, m_id, m_activeAnimations[i]->group(), m_activeAnimations[i]->targetProperty(), monotonicTime));
                 for (size_t j = i + 1; j < m_activeAnimations.size(); ++j) {
                     if (m_activeAnimations[i]->group() == m_activeAnimations[j]->group()) {
                         m_activeAnimations[j]->setRunState(ActiveAnimation::Running, monotonicTime);
                         if (!m_activeAnimations[j]->hasSetStartTime())
                             m_activeAnimations[j]->setStartTime(monotonicTime);
                     }
                 }
             }
         }
     }
@@ skipping 35 matching lines @@
                     break;
                 }
             }
         }
         if (allAnimsWithSameIdAreFinished) {
             // We now need to remove all animations with the same group id as groupId
             // (and send along animation finished notifications, if necessary).
             for (size_t j = i; j < m_activeAnimations.size(); j++) {
                 if (groupId == m_activeAnimations[j]->group()) {
                     if (events)
-                        events->push_back(AnimationEvent(AnimationEvent::Finished, m_client->id(), m_activeAnimations[j]->group(), m_activeAnimations[j]->targetProperty(), monotonicTime));
+                        events->push_back(AnimationEvent(AnimationEvent::Finished, m_id, m_activeAnimations[j]->group(), m_activeAnimations[j]->targetProperty(), monotonicTime));
                     m_activeAnimations[j]->setRunState(ActiveAnimation::WaitingForDeletion, monotonicTime);
                 }
             }
         }
     }
 }
 
 void LayerAnimationController::purgeAnimationsMarkedForDeletion()
 {
     for (size_t i = 0; i < m_activeAnimations.size();) {
@@ skipping 17 matching lines @@
             toAdd = m_activeAnimations[i]->cloneAndInitialize(ActiveAnimation::ControllingInstance, initialRunState, startTime).Pass();
         } else
             toAdd = m_activeAnimations[i]->clone(ActiveAnimation::ControllingInstance).Pass();
 
         controllerImpl->addAnimation(toAdd.Pass());
     }
 }
 
 void LayerAnimationController::tickAnimations(double monotonicTime)
 {
+    // FIXME(vollick) we should really be using base::TimeTicks instead of
+    // doubles throughout this class. For now, we need to recalculate now so
+    // that we can express the last update times for opacity and floats as
+    // base::TimeTicks.
+    base::TimeTicks now = base::TimeTicks::Now();
+
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
         if (m_activeAnimations[i]->runState() == ActiveAnimation::Running || m_activeAnimations[i]->runState() == ActiveAnimation::Paused) {
             double trimmed = m_activeAnimations[i]->trimTimeToCurrentIteration(monotonicTime);
 
             // Animation assumes its initial value until it gets the synchronized start time
             // from the impl thread and can start ticking.
             if (m_activeAnimations[i]->needsSynchronizedStartTime())
                 trimmed = 0;
 
             switch (m_activeAnimations[i]->targetProperty()) {
 
             case ActiveAnimation::Transform: {
                 const TransformAnimationCurve* transformAnimationCurve = m_activeAnimations[i]->curve()->toTransformAnimationCurve();
-                const gfx::Transform matrix = transformAnimationCurve->getValue(trimmed).toTransform();
+                m_transform = transformAnimationCurve->getValue(trimmed).toTransform();
+                m_transformLastUpdateTime = now;
                 if (m_activeAnimations[i]->isFinishedAt(monotonicTime))
                     m_activeAnimations[i]->setRunState(ActiveAnimation::Finished, monotonicTime);
-
-                m_client->setTransformFromAnimation(matrix);
                 break;
             }
 
             case ActiveAnimation::Opacity: {
                 const FloatAnimationCurve* floatAnimationCurve = m_activeAnimations[i]->curve()->toFloatAnimationCurve();
-                const float opacity = floatAnimationCurve->getValue(trimmed);
+                m_opacity = floatAnimationCurve->getValue(trimmed);
+                m_opacityLastUpdateTime = now;
                 if (m_activeAnimations[i]->isFinishedAt(monotonicTime))
                     m_activeAnimations[i]->setRunState(ActiveAnimation::Finished, monotonicTime);
-
-                m_client->setOpacityFromAnimation(opacity);
                 break;
             }
 
             // Do nothing for sentinel value.
             case ActiveAnimation::TargetPropertyEnumSize:
                 NOTREACHED();
             }
         }
     }
 }
 
+void LayerAnimationController::updateRegistration()
+{
+    if (m_registrar) {
+        if (hasActiveAnimation())
+            m_registrar->Register(this);
+        else
+            m_registrar->Unregister(this);
+    }
+}
+
 }  // namespace cc