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

cc/single_thread_proxy.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/single_thread_proxy.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/draw_quad.h"
 #include "cc/graphics_context.h"
 #include "cc/layer_tree_host.h"
 #include "cc/resource_update_controller.h"
 #include "cc/timer.h"
-#include <wtf/CurrentTime.h>
 
 namespace cc {
 
 scoped_ptr<Proxy> SingleThreadProxy::create(LayerTreeHost* layerTreeHost)
 {
     return make_scoped_ptr(new SingleThreadProxy(layerTreeHost)).PassAs<Proxy>();
 }
 
 SingleThreadProxy::SingleThreadProxy(LayerTreeHost* layerTreeHost)
     : m_layerTreeHost(layerTreeHost)
@@ skipping 31 matching lines @@
 
     if (m_layerTreeHostImpl->isContextLost())
         return false;
 
     m_layerTreeHostImpl->swapBuffers();
     didSwapFrame();
 
     return true;
 }
 
-void SingleThreadProxy::startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double duration)
+void SingleThreadProxy::startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, base::TimeDelta duration)
 {
-    m_layerTreeHostImpl->startPageScaleAnimation(targetPosition, useAnchor, scale, monotonicallyIncreasingTime(), duration);
+    m_layerTreeHostImpl->startPageScaleAnimation(targetPosition, useAnchor, scale, base::TimeTicks::Now(), duration);
 }
 
 void SingleThreadProxy::finishAllRendering()
 {
     DCHECK(Proxy::isMainThread());
     {
         DebugScopedSetImplThread impl;
         m_layerTreeHostImpl->finishAllRendering();
     }
 }
@@ skipping 189 matching lines @@
 void SingleThreadProxy::setNeedsRedrawOnImplThread()
 {
     m_layerTreeHost->scheduleComposite();
 }
 
 void SingleThreadProxy::setNeedsCommitOnImplThread()
 {
     m_layerTreeHost->scheduleComposite();
 }
 
-void SingleThreadProxy::postAnimationEventsToMainThreadOnImplThread(scoped_ptr<AnimationEventsVector> events, double wallClockTime)
+void SingleThreadProxy::postAnimationEventsToMainThreadOnImplThread(scoped_ptr<AnimationEventsVector> events, base::Time wallClockTime)
 {
     DCHECK(Proxy::isImplThread());
     DebugScopedSetMainThread main;
     m_layerTreeHost->setAnimationEvents(events.Pass(), wallClockTime);
 }
 
 bool SingleThreadProxy::reduceContentsTextureMemoryOnImplThread(size_t limitBytes, int priorityCutoff)
 {
     DCHECK(isImplThread());
     if (!m_layerTreeHost->contentsTextureManager())
@@ skipping 65 matching lines @@
 
 bool SingleThreadProxy::doComposite()
 {
     DCHECK(!m_contextLost);
     {
         DebugScopedSetImplThread impl;
 
         if (!m_layerTreeHostImpl->visible())
             return false;
 
-        double monotonicTime = monotonicallyIncreasingTime();
-        double wallClockTime = currentTime();
-        m_layerTreeHostImpl->animate(monotonicTime, wallClockTime);
+        m_layerTreeHostImpl->animate(base::TimeTicks::Now(), base::Time::Now());
 
         // We guard prepareToDraw() with canDraw() because it always returns a valid frame, so can only
         // be used when such a frame is possible. Since drawLayers() depends on the result of
         // prepareToDraw(), it is guarded on canDraw() as well.
         if (!m_layerTreeHostImpl->canDraw())
             return false;
 
         LayerTreeHostImpl::FrameData frame;
         m_layerTreeHostImpl->prepareToDraw(frame);
         m_layerTreeHostImpl->drawLayers(frame);
@@ skipping 11 matching lines @@
 
 void SingleThreadProxy::didSwapFrame()
 {
     if (m_nextFrameIsNewlyCommittedFrame) {
         m_nextFrameIsNewlyCommittedFrame = false;
         m_layerTreeHost->didCommitAndDrawFrame();
     }
 }
 
 }