Remove WTF::currentTime() / WTF::monotonicallyIncreasingTime() uses from cc

cc/layer_tree_host_unittest.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 "config.h"
 
 #include "cc/layer_tree_host.h"
 
 #include "base/synchronization/lock.h"
 #include "cc/content_layer.h"
@@ skipping 486 matching lines @@
     LayerTreeHostTestSetNeedsAnimateShouldNotSetCommitRequested()
         : m_numCommits(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         postSetNeedsCommitToMainThread();
     }
 
-    virtual void animate(double monotonicTime) OVERRIDE
+    virtual void animate(base::TimeTicks monotonicTime) OVERRIDE
     {
         // We skip the first commit becasue its the commit that populates the
         // impl thread with a tree.
         if (!m_numCommits)
             return;
 
         m_layerTreeHost->setNeedsAnimate();
         // Right now, commitRequested is going to be true, because during
         // beginFrame, we force commitRequested to true to prevent requests from
         // hitting the impl thread. But, when the next didCommit happens, we should
@@ skipping 39 matching lines @@
     LayerTreeHostTestSetNeedsAnimateInsideAnimationCallback()
         : m_numAnimates(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         postSetNeedsAnimateToMainThread();
     }
 
-    virtual void animate(double) OVERRIDE
+    virtual void animate(base::TimeTicks) OVERRIDE
     {
         if (!m_numAnimates) {
             m_layerTreeHost->setNeedsAnimate();
             m_numAnimates++;
             return;
         }
         endTest();
     }
 
     virtual void afterTest() OVERRIDE
@@ skipping 10 matching lines @@
 }
 
 // Add a layer animation and confirm that LayerTreeHostImpl::animateLayers does get
 // called and continues to get called.
 class LayerTreeHostTestAddAnimation : public LayerTreeHostTest {
 public:
     LayerTreeHostTestAddAnimation()
         : m_numAnimates(0)
         , m_receivedAnimationStartedNotification(false)
         , m_startTime(0)
-        , m_firstMonotonicTime(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         postAddInstantAnimationToMainThread();
     }
 
-    virtual void animateLayers(LayerTreeHostImpl* layerTreeHostImpl, double monotonicTime) OVERRIDE
+    virtual void animateLayers(LayerTreeHostImpl* layerTreeHostImpl, base::TimeTicks monotonicTime) OVERRIDE
     {
         if (!m_numAnimates) {
             // The animation had zero duration so layerTreeHostImpl should no
             // longer need to animate its layers.
             EXPECT_FALSE(layerTreeHostImpl->needsAnimateLayers());
             m_numAnimates++;
             m_firstMonotonicTime = monotonicTime;
             return;
         }
         EXPECT_LT(0, m_startTime);
-        EXPECT_LT(0, m_firstMonotonicTime);
-        EXPECT_NE(m_startTime, m_firstMonotonicTime);
         EXPECT_TRUE(m_receivedAnimationStartedNotification);
         endTest();
     }
 
     virtual void notifyAnimationStarted(double wallClockTime) OVERRIDE
     {
         m_receivedAnimationStartedNotification = true;
         m_startTime = wallClockTime;
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 
 private:
     int m_numAnimates;
     bool m_receivedAnimationStartedNotification;
     double m_startTime;
-    double m_firstMonotonicTime;
+    base::TimeTicks m_firstMonotonicTime;
 };
 
 TEST_F(LayerTreeHostTestAddAnimation, runMultiThread)
 {
     runTest(true);
 }
 
 // Add a layer animation to a layer, but continually fail to draw. Confirm that after
 // a while, we do eventually force a draw.
 class LayerTreeHostTestCheckerboardDoesNotStarveDraws : public LayerTreeHostTest {
 public:
     LayerTreeHostTestCheckerboardDoesNotStarveDraws()
         : m_startedAnimating(false)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         postAddAnimationToMainThread();
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 
-    virtual void animateLayers(LayerTreeHostImpl* layerTreeHostImpl, double monotonicTime) OVERRIDE
+    virtual void animateLayers(LayerTreeHostImpl* layerTreeHostImpl, base::TimeTicks monotonicTime) OVERRIDE
     {
         m_startedAnimating = true;
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl*) OVERRIDE
     {
         if (m_startedAnimating)
             endTest();
     }
 
@@ skipping 21 matching lines @@
     }
 
     virtual void beginTest() OVERRIDE
     {
         postAddAnimationToMainThread();
     }
 
     // Use willAnimateLayers to set visible false before the animation runs and
     // causes a commit, so we block the second visible animate in single-thread
     // mode.
-    virtual void willAnimateLayers(LayerTreeHostImpl* layerTreeHostImpl, double monotonicTime) OVERRIDE
+    virtual void willAnimateLayers(LayerTreeHostImpl* layerTreeHostImpl, base::TimeTicks monotonicTime) OVERRIDE
     {
         if (m_numAnimates < 2) {
             if (!m_numAnimates) {
                 // We have a long animation running. It should continue to tick even if we are not visible.
                 postSetVisibleToMainThread(false);
             }
             m_numAnimates++;
             return;
         }
         endTest();
@@ skipping 14 matching lines @@
 public:
     LayerTreeHostTestAddAnimationWithTimingFunction()
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         postAddAnimationToMainThread();
     }
 
-    virtual void animateLayers(LayerTreeHostImpl* layerTreeHostImpl, double monotonicTime) OVERRIDE
+    virtual void animateLayers(LayerTreeHostImpl* layerTreeHostImpl, base::TimeTicks monotonicTime) OVERRIDE
     {
         const ActiveAnimation* animation = m_layerTreeHost->rootLayer()->layerAnimationController()->getActiveAnimation(0, ActiveAnimation::Opacity);
         if (!animation)
             return;
         const FloatAnimationCurve* curve = animation->curve()->toFloatAnimationCurve();
         float startOpacity = curve->getValue(0);
         float endOpacity = curve->getValue(curve->duration());
         float linearlyInterpolatedOpacity = 0.25 * endOpacity + 0.75 * startOpacity;
         double time = curve->duration() * 0.25;
         // If the linear timing function associated with this animation was not picked up,
@@ skipping 52 matching lines @@
     LayerTreeHostTestSynchronizeAnimationStartTimes()
         : m_layerTreeHostImpl(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         postAddAnimationToMainThread();
     }
 
-    // This is guaranteed to be called before LayerTreeHostImpl::animateLayers.
-    virtual void willAnimateLayers(LayerTreeHostImpl* layerTreeHostImpl, double monotonicTime) OVERRIDE
+    // This is guaranteed to be called before CCLayerTreeHostImpl::animateLayers.
+    virtual void willAnimateLayers(LayerTreeHostImpl* layerTreeHostImpl, base::TimeTicks monotonicTime) OVERRIDE
     {
         m_layerTreeHostImpl = layerTreeHostImpl;
     }
 
     virtual void notifyAnimationStarted(double time) OVERRIDE
     {
         EXPECT_TRUE(m_layerTreeHostImpl);
 
         LayerAnimationController* controllerImpl = m_layerTreeHostImpl->rootLayer()->layerAnimationController();
         LayerAnimationController* controller = m_layerTreeHost->rootLayer()->layerAnimationController();
@@ skipping 239 matching lines @@
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->rootLayer()->setScrollable(true);
         m_layerTreeHost->rootLayer()->setScrollPosition(IntPoint());
         postSetNeedsCommitToMainThread();
         postSetNeedsRedrawToMainThread();
     }
 
     void requestStartPageScaleAnimation()
     {
-        layerTreeHost()->startPageScaleAnimation(IntSize(), false, 1.25, 0);
+        layerTreeHost()->startPageScaleAnimation(IntSize(), false, 1.25, base::TimeDelta());
     }
 
     virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
         impl->rootLayer()->setScrollable(true);
         impl->rootLayer()->setScrollPosition(IntPoint());
         impl->setPageScaleFactorAndLimits(impl->pageScaleFactor(), 0.5, 2);
 
         // We request animation only once.
         if (!m_animationRequested) {
@@ skipping 2051 matching lines @@
     }
 
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setViewportSize(IntSize(10, 10), IntSize(10, 10));
         m_layerTreeHost->rootLayer()->setBounds(IntSize(10, 10));
 
         postSetNeedsCommitToMainThread();
     }
 
-    virtual void animate(double) OVERRIDE
+    virtual void animate(base::TimeTicks) OVERRIDE
     {
         m_layerTreeHost->setNeedsAnimate();
     }
 
     virtual void layout() OVERRIDE
     {
         m_layerTreeHost->rootLayer()->setNeedsDisplay();
     }
 
     virtual void commitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE
@@ skipping 72 matching lines @@
     int m_numCommitsDeferred;
     int m_numCompleteCommits;
 };
 
 TEST_F(LayerTreeHostTestDeferCommits, runMultiThread)
 {
     runTest(true);
 }
 
 } // namespace