Defer starting of animations until after compositing update

Source/core/animation/css/CSSPendingAnimations.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 23 matching lines @@
 #include "core/animation/Animation.h"
 #include "core/animation/DocumentTimeline.h"
 #include "core/frame/FrameView.h"
 #include "core/rendering/RenderLayer.h"
 
 namespace WebCore {
 
 void CSSPendingAnimations::add(Player* player)
 {
     ASSERT(player->source()->isAnimation());
-    // The actual start time is either this value, or the time that
-    // this animation, or an animation that it is synchronized with
-    // is started on the compositor.
-    const double defaultStartTime = player->timeline()->currentTime();
-    m_pending.append(std::make_pair(player, defaultStartTime));
+    m_pending.append(player);
 }
 
 bool CSSPendingAnimations::startPendingAnimations()
 {
-    // FIXME: This is called from within style recalc, at which point compositor state is not up to date.
-    // https://code.google.com/p/chromium/issues/detail?id=339847
-    DisableCompositingQueryAsserts disabler;
-
     bool startedOnCompositor = false;
     for (size_t i = 0; i < m_pending.size(); ++i) {
-        if (m_pending[i].first->maybeStartAnimationOnCompositor())
+        if (m_pending[i]->maybeStartAnimationOnCompositor())
             startedOnCompositor = true;
     }
 
     // If any animations were started on the compositor, all remaining
     // need to wait for a synchronized start time. Otherwise they may
     // start immediately.
     if (startedOnCompositor) {
         for (size_t i = 0; i < m_pending.size(); ++i)
-            m_waitingForCompositorAnimationStart.append(m_pending[i].first);
+            m_waitingForCompositorAnimationStart.append(m_pending[i]);
     } else {
         for (size_t i = 0; i < m_pending.size(); ++i) {
-            m_pending[i].first->setStartTime(m_pending[i].second);
-            m_pending[i].first->update();
+            m_pending[i]->setStartTime(m_pending[i]->timeline()->currentTime());
+            m_pending[i]->update();
         }
     }
     m_pending.clear();
 
     if (startedOnCompositor || m_waitingForCompositorAnimationStart.isEmpty())
         return !m_waitingForCompositorAnimationStart.isEmpty();
 
     // 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())
@@ skipping 10 matching lines @@
     for (size_t i = 0; i < m_waitingForCompositorAnimationStart.size(); ++i) {
         Player* player = m_waitingForCompositorAnimationStart[i].get();
         player->setStartTime(monotonicAnimationStartTime - player->timeline()->zeroTime());
         player->update();
     }
 
     m_waitingForCompositorAnimationStart.clear();
 }
 
 } // namespace