Allow impl-only animations, and return opacity values via AnimationEvents.

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 <algorithm>
 
 #include "cc/animation.h"
 #include "cc/animation_registrar.h"
@@ skipping 107 matching lines @@
         return;
 
     startAnimationsWaitingForNextTick(monotonicTime);
     startAnimationsWaitingForStartTime(monotonicTime);
     startAnimationsWaitingForTargetAvailability(monotonicTime);
     resolveConflicts(monotonicTime);
     tickAnimations(monotonicTime);
     m_lastTickTime = monotonicTime;
 }
 
+void LayerAnimationController::accumulatePropertyUpdates(double monotonicTime,
+    AnimationEventsVector* events)
+{
+    if (!events)
+        return;
+
+    for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
+        Animation* animation = m_activeAnimations[i];
+        if (!animation->isImplOnly())
+            continue;
+
+        if (animation->targetProperty() == Animation::Opacity) {
+            AnimationEvent event(AnimationEvent::PropertyUpdate,
+                                 m_id, animation->group(),
+                                 Animation::Opacity, monotonicTime);
+            event.opacity = animation->curve()->toFloatAnimationCurve()->getValue(monotonicTime);
+
+            events->push_back(event);
+        }
+        else if (animation->targetProperty() == Animation::Transform) {
+            AnimationEvent event(AnimationEvent::PropertyUpdate,
+                                 m_id, animation->group(),
+                                 Animation::Transform, monotonicTime);
+            event.transform = animation->curve()->toTransformAnimationCurve()->getValue(monotonicTime);
+            events->push_back(event);
+        }
+    }
+}
+
 void LayerAnimationController::updateState(AnimationEventsVector* events)
 {
     if (!hasActiveObserver())
         return;
 
     promoteStartedAnimations(m_lastTickTime, events);
     markFinishedAnimations(m_lastTickTime);
     markAnimationsForDeletion(m_lastTickTime, events);
     startAnimationsWaitingForTargetAvailability(m_lastTickTime);
     promoteStartedAnimations(m_lastTickTime, events);
 
+    accumulatePropertyUpdates(m_lastTickTime, events);
+
     updateActivation();
 }
 
 void LayerAnimationController::addAnimation(scoped_ptr<Animation> animation)
 {
     m_activeAnimations.push_back(animation.Pass());
     updateActivation();
 }
 
 Animation* LayerAnimationController::getAnimation(int groupId, Animation::TargetProperty targetProperty) const
@@ skipping 89 matching lines @@
         Animation::RunState initialRunState = Animation::WaitingForTargetAvailability;
         double startTime = 0;
         scoped_ptr<Animation> toAdd(m_activeAnimations[i]->cloneAndInitialize(Animation::ControllingInstance, initialRunState, startTime));
         DCHECK(!toAdd->needsSynchronizedStartTime());
         controllerImpl->addAnimation(toAdd.Pass());
     }
 }
 
 struct IsCompleted {
     IsCompleted(const LayerAnimationController& mainThreadController) : m_mainThreadController(mainThreadController) { }
-    bool operator()(Animation* animation) const { return !m_mainThreadController.getAnimation(animation->group(), animation->targetProperty()); }
+    bool operator()(Animation* animation) const {
+        if (animation->isImplOnly())
+            return false;
+        return !m_mainThreadController.getAnimation(animation->group(), animation->targetProperty()); }
 private:
     const LayerAnimationController& m_mainThreadController;
 };
 
 void LayerAnimationController::removeAnimationsCompletedOnMainThread(LayerAnimationController* controllerImpl) const
 {
     // Delete all impl thread animations for which there is no corresponding main thread animation.
     // Each iteration, controller->m_activeAnimations.size() is decremented or i is incremented
     // guaranteeing progress towards loop termination.
     ScopedPtrVector<Animation>& animations = controllerImpl->m_activeAnimations;
@@ skipping 237 matching lines @@
         ObserverListBase<LayerAnimationValueObserver>::Iterator it(m_observers);
         LayerAnimationValueObserver* obs;
         while ((obs = it.GetNext()) != NULL)
             if (obs->IsActive())
                 return true;
     }
     return false;
 }
 
 }  // namespace cc