Web Animations: Sort Animations in the AnimationStack

Source/core/animation/AnimationStack.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 12 matching lines @@
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/animation/AnimationStack.h"
 #include "core/animation/Interpolation.h"

[alancutter (OOO until 2018), 2014/03/26 01:23:03]

Not sure why style never picked up on this but this Interpolation.h include
should be one line lower.

[Timothy Loh, 2014/03/26 03:00:43]

Done.

 
 #include "core/animation/css/CSSAnimations.h"
 
 namespace WebCore {
 
 namespace {
 
 void copyToActiveInterpolationMap(const Vector<RefPtr<WebCore::Interpolation> >& source, HashMap<CSSPropertyID, RefPtr<WebCore::Interpolation> >& target)
 {
     for (Vector<RefPtr<WebCore::Interpolation> >::const_iterator iter = source.begin(); iter != source.end(); ++iter) {
         RefPtr<WebCore::Interpolation> interpolation = *iter;
         WebCore::StyleInterpolation *styleInterpolation = toStyleInterpolation(interpolation.get());
         target.set(styleInterpolation->id(), styleInterpolation);
     }
 }
 
+bool compareAnimations(Animation* animation1, Animation* animation2)
+{
+    ASSERT(animation1->player() && animation2->player());
+    return AnimationPlayer::hasLowerPriority(animation1->player(), animation2->player());
+}
+
+void copyNewAnimationsToActiveInterpolationMap(const Vector<InertAnimation*>& newAnimations, HashMap<CSSPropertyID, RefPtr<Interpolation> >& result)
+{
+    for (size_t i = 0; i < newAnimations.size(); ++i) {
+        OwnPtr<Vector<RefPtr<Interpolation> > > sample = newAnimations[i]->sample();
+        if (sample) {
+            copyToActiveInterpolationMap(*sample, result);
+        }
+    }
+}
+
 } // namespace
 
 bool AnimationStack::affects(CSSPropertyID property) const
 {
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
         if (m_activeAnimations[i]->affects(property))
             return true;
     }
     return false;
 }
 
 bool AnimationStack::hasActiveAnimationsOnCompositor(CSSPropertyID property) const
 {
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
         if (m_activeAnimations[i]->hasActiveAnimationsOnCompositor(property))
             return true;
     }
     return false;
 }
 
-HashMap<CSSPropertyID, RefPtr<Interpolation> > AnimationStack::activeInterpolations(const AnimationStack* animationStack, const Vector<InertAnimation*>* newAnimations, const HashSet<const AnimationPlayer*>* cancelledAnimationPlayers, Animation::Priority priority)
+HashMap<CSSPropertyID, RefPtr<Interpolation> > AnimationStack::activeInterpolations(AnimationStack* animationStack, const Vector<InertAnimation*>* newAnimations, const HashSet<const AnimationPlayer*>* cancelledAnimationPlayers, Animation::Priority priority, double timelineCurrentTime)
 {
+    // We don't exactly know when new animations will start, but timelineCurrentTime is a good estimate.

[dstockwell, 2014/03/26 01:32:21]

We should probably track the start time for the purpose of sorting separately
from the start time for the purpose of timing calculations. This would allow us
to use the time at which the player was first constructed for sorting compositor
animations.

[Timothy Loh, 2014/03/26 03:00:43]

Done.

+
     HashMap<CSSPropertyID, RefPtr<Interpolation> > result;
 
     if (animationStack) {
-        const Vector<Animation*>& animations = animationStack->m_activeAnimations;
+        Vector<Animation*>& animations = animationStack->m_activeAnimations;
+        std::sort(animations.begin(), animations.end(), compareAnimations);
         for (size_t i = 0; i < animations.size(); ++i) {
             Animation* animation = animations[i];
             if (animation->priority() != priority)
                 continue;
             if (cancelledAnimationPlayers && cancelledAnimationPlayers->contains(animation->player()))
                 continue;
+            if (animation->player()->startTime() > timelineCurrentTime && newAnimations) {
+                copyNewAnimationsToActiveInterpolationMap(*newAnimations, result);
+                newAnimations = 0;
+            }
             copyToActiveInterpolationMap(animation->activeInterpolations(), result);
         }
     }
 
-    if (newAnimations) {
-        for (size_t i = 0; i < newAnimations->size(); ++i) {
-            OwnPtr<Vector<RefPtr<Interpolation> > > sample = newAnimations->at(i)->sample();
-            if (sample) {
-                copyToActiveInterpolationMap(*sample, result);
-            }
-        }
-    }
+    if (newAnimations)
+        copyNewAnimationsToActiveInterpolationMap(*newAnimations, result);
 
     return result;
 }
 
 } // namespace WebCore