Make LayerTreeHost::animateLayers take a wall clock time in addition to a monotonic time

cc/layer_tree_host.cc

 // Copyright 2011 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_tree_host.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 200 matching lines @@
 {
     DCHECK(m_proxy->isMainThread());
     m_proxy->acquireLayerTextures();
 }
 
 void LayerTreeHost::didBeginFrame()
 {
     m_client->didBeginFrame();
 }
 
-void LayerTreeHost::updateAnimations(base::TimeTicks frameBeginTime)
+void LayerTreeHost::updateAnimations(base::TimeTicks monotonicFrameBeginTime, base::Time wallClockFrameBeginTime)
 {
     m_animating = true;
-    m_client->animate((frameBeginTime - base::TimeTicks()).InSecondsF());
-    animateLayers(frameBeginTime);
+    m_client->animate((monotonicFrameBeginTime - base::TimeTicks()).InSecondsF());
+    animateLayers(monotonicFrameBeginTime, wallClockFrameBeginTime);
     m_animating = false;
 
     m_renderingStats.numAnimationFrames++;
 }
 
 void LayerTreeHost::didStopFlinging()
 {
   m_proxy->mainThreadHasStoppedFlinging();
 }
 
@@ skipping 578 matching lines @@
 
 void LayerTreeHost::setDeviceScaleFactor(float deviceScaleFactor)
 {
     if (deviceScaleFactor ==  m_deviceScaleFactor)
         return;
     m_deviceScaleFactor = deviceScaleFactor;
 
     setNeedsCommit();
 }
 
-void LayerTreeHost::animateLayers(base::TimeTicks time)
+void LayerTreeHost::animateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime)
 {
     if (!m_settings.acceleratedAnimationEnabled || m_animationRegistrar->active_animation_controllers().empty())
         return;
 
     TRACE_EVENT0("cc", "LayerTreeHostImpl::animateLayers");
 
-    double monotonicTime = (time - base::TimeTicks()).InSecondsF();
+    double monotonicTimeInSeconds = (monotonicTime - base::TimeTicks()).InSecondsF();
 
     AnimationRegistrar::AnimationControllerMap copy = m_animationRegistrar->active_animation_controllers();
     for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin(); iter != copy.end(); ++iter)
-        (*iter).second->animate(monotonicTime, 0);
+        (*iter).second->animate(monotonicTimeInSeconds, 0);
 }
 
 void LayerTreeHost::setAnimationEventsRecursive(const AnimationEventsVector& events, Layer* layer, base::Time wallClockTime)
 {
     if (!layer)
         return;
 
     for (size_t eventIndex = 0; eventIndex < events.size(); ++eventIndex) {
         if (layer->id() == events[eventIndex].layerId) {
             if (events[eventIndex].type == AnimationEvent::Started)
                 layer->notifyAnimationStarted(events[eventIndex], wallClockTime.ToDoubleT());
             else
                 layer->notifyAnimationFinished(wallClockTime.ToDoubleT());
         }
     }
 
     for (size_t childIndex = 0; childIndex < layer->children().size(); ++childIndex)
         setAnimationEventsRecursive(events, layer->children()[childIndex].get(), wallClockTime);
 }
 
 skia::RefPtr<SkPicture> LayerTreeHost::capturePicture()
 {
     return m_proxy->capturePicture();
 }
 
 }  // namespace cc