Web Animations: Compositor start notification should only apply to animations in a matching group

Source/core/animation/CompositorPendingAnimations.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 44 matching lines @@
     }
 }
 
 bool CompositorPendingAnimations::update(bool startOnCompositor)
 {
     WillBeHeapVector<RawPtrWillBeMember<AnimationPlayer>> waitingForStartTime;
     bool startedSynchronizedOnCompositor = false;
 
     WillBeHeapVector<RefPtrWillBeMember<AnimationPlayer> > players;
     players.swap(m_pending);
+    int compositorGroup = ++m_compositorGroup;
+    if (compositorGroup == 0) {
+        // Wrap around, skipping 0.
+        compositorGroup = ++m_compositorGroup;
+    }
 
     for (size_t i = 0; i < players.size(); ++i) {
         AnimationPlayer& player = *players[i].get();
         bool hadCompositorAnimation = player.hasActiveAnimationsOnCompositor();
-        player.preCommit(startOnCompositor);
+        player.preCommit(compositorGroup, startOnCompositor);
         if (player.hasActiveAnimationsOnCompositor() && !hadCompositorAnimation) {
             startedSynchronizedOnCompositor = true;
         }
 
         if (player.playing() && !player.hasStartTime()) {
             waitingForStartTime.append(&player);
         }
     }
 
     // If any synchronized animations were started on the compositor, all
@@ skipping 27 matching lines @@
     if (m_waitingForCompositorAnimationStart.isEmpty())
         return false;
 
     // Check if we're still waiting for any compositor animations to start.
     for (size_t i = 0; i < m_waitingForCompositorAnimationStart.size(); ++i) {
         if (m_waitingForCompositorAnimationStart[i].get()->hasActiveAnimationsOnCompositor())
             return true;
     }
 
     // If not, go ahead and start any animations that were waiting.
-    notifyAnimationStarted(monotonicallyIncreasingTime(), false);
+    notifyCompositorAnimationStarted(monotonicallyIncreasingTime());
 
     ASSERT(m_pending.isEmpty());
     return false;
 }
 
-void CompositorPendingAnimations::notifyAnimationStarted(double monotonicAnimationStartTime, bool startedOnCompositor)
+void CompositorPendingAnimations::notifyCompositorAnimationStarted(double monotonicAnimationStartTime, int compositorGroup)
 {
     TRACE_EVENT0("blink", "CompositorPendingAnimations::notifyCompositorAnimationStarted");
-    for (size_t i = 0; i < m_waitingForCompositorAnimationStart.size(); ++i) {
-        AnimationPlayer* player = m_waitingForCompositorAnimationStart[i].get();
-        if (player->hasStartTime())
+    WillBeHeapVector<RefPtrWillBeMember<AnimationPlayer> > players;
+    players.swap(m_waitingForCompositorAnimationStart);
+
+    for (size_t i = 0; i < players.size(); ++i) {
+        AnimationPlayer* player = players[i].get();
+        if (player->hasStartTime() || player->playStateInternal() != AnimationPlayer::Pending) {
+            // Already started or no longer relevant.
             continue;
-        double effectiveStartTime = monotonicAnimationStartTime - player->timeline()->zeroTime();
-        if (startedOnCompositor) {
-            player->notifyCompositorStartTime(effectiveStartTime);
-        } else {
-            player->notifyStartTime(effectiveStartTime);
         }
+        if (compositorGroup && player->compositorGroup() != compositorGroup) {
+            // Still waiting.
+            m_waitingForCompositorAnimationStart.append(player);
+            continue;
+        }
+        player->notifyCompositorStartTime(monotonicAnimationStartTime - player->timeline()->zeroTime());
     }
 
-    m_waitingForCompositorAnimationStart.clear();
-}
-
-void CompositorPendingAnimations::notifyCompositorAnimationStarted(double monotonicAnimationStartTime)
-{
-    TRACE_EVENT0("blink", "CompositorPendingAnimations::notifyCompositorAnimationStarted");
-    notifyAnimationStarted(monotonicAnimationStartTime, true);
 }
 
 void CompositorPendingAnimations::trace(Visitor* visitor)
 {
     visitor->trace(m_pending);
     visitor->trace(m_waitingForCompositorAnimationStart);
 }
 
 } // namespace