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

cc/layer_tree_host_impl.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_impl.h"
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 13 matching lines @@
 #include "cc/page_scale_animation.h"
 #include "cc/prioritized_texture_manager.h"
 #include "cc/render_pass_draw_quad.h"
 #include "cc/rendering_stats.h"
 #include "cc/scrollbar_animation_controller.h"
 #include "cc/scrollbar_layer_impl.h"
 #include "cc/settings.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/software_renderer.h"
 #include "cc/texture_uploader.h"
-#include <wtf/CurrentTime.h>
 #include <algorithm>
 
 using WebKit::WebTransformationMatrix;
 
 namespace {
 
 void didVisibilityChange(cc::LayerTreeHostImpl* id, bool visible)
 {
     if (visible) {
         TRACE_EVENT_ASYNC_BEGIN1("webkit", "LayerTreeHostImpl::setVisible", id, "LayerTreeHostImpl", id);
@@ skipping 123 matching lines @@
         m_timeSource->setActive(false);
     }
 
     virtual void onTimerTick() OVERRIDE
     {
         // FIXME: We require that animate be called on the impl thread. This
         // avoids asserts in single threaded mode. Ideally background ticking
         // would be handled by the proxy/scheduler and this could be removed.
         DebugScopedSetImplThread impl;
 
-        m_layerTreeHostImpl->animate(monotonicallyIncreasingTime(), currentTime());
+        m_layerTreeHostImpl->animate(base::TimeTicks::Now(), base::Time::Now());
     }
 
     void setActive(bool active)
     {
         if (active != m_timeSource->active())
             m_timeSource->setActive(active);
     }
 
 private:
     LayerTreeHostImplTimeSourceAdapter(LayerTreeHostImpl* layerTreeHostImpl, scoped_refptr<DelayBasedTimeSource> timeSource)
@@ skipping 96 matching lines @@
         return false;
     }
     return true;
 }
 
 GraphicsContext* LayerTreeHostImpl::context() const
 {
     return m_context.get();
 }
 
-void LayerTreeHostImpl::animate(double monotonicTime, double wallClockTime)
+void LayerTreeHostImpl::animate(base::TimeTicks monotonicTime, base::Time wallClockTime)
 {
     animatePageScale(monotonicTime);
     animateLayers(monotonicTime, wallClockTime);
     animateScrollbars(monotonicTime);
 }
 
-void LayerTreeHostImpl::startPageScaleAnimation(const IntSize& targetPosition, bool anchorPoint, float pageScale, double startTime, double duration)
+void LayerTreeHostImpl::startPageScaleAnimation(const IntSize& targetPosition, bool anchorPoint, float pageScale, base::TimeTicks startTime, base::TimeDelta duration)
 {
     if (!m_rootScrollLayerImpl)
         return;
 
     IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());
     scrollTotal.scale(m_pinchZoomViewport.pageScaleDelta());
     float scaleTotal = m_pinchZoomViewport.totalPageScaleFactor();
     IntSize scaledContentSize = contentSize();
     scaledContentSize.scale(m_pinchZoomViewport.pageScaleDelta());
 
-    m_pageScaleAnimation = PageScaleAnimation::create(scrollTotal, scaleTotal, m_deviceViewportSize, scaledContentSize, startTime);
+    double startTimeSeconds = (startTime - base::TimeTicks()).InSecondsF();
+    m_pageScaleAnimation = PageScaleAnimation::create(scrollTotal, scaleTotal, m_deviceViewportSize, scaledContentSize, startTimeSeconds);
 
     if (anchorPoint) {
         IntSize windowAnchor(targetPosition);
         windowAnchor.scale(scaleTotal / pageScale);
         windowAnchor -= scrollTotal;
-        m_pageScaleAnimation->zoomWithAnchor(windowAnchor, pageScale, duration);
+        m_pageScaleAnimation->zoomWithAnchor(windowAnchor, pageScale, duration.InSecondsF());
     } else
-        m_pageScaleAnimation->zoomTo(targetPosition, pageScale, duration);
+        m_pageScaleAnimation->zoomTo(targetPosition, pageScale, duration.InSecondsF());
 
     m_client->setNeedsRedrawOnImplThread();
     m_client->setNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::scheduleAnimation()
 {
     m_client->setNeedsRedrawOnImplThread();
 }
 
@@ skipping 136 matching lines @@
     if (drawFrame)
         occlusionTracker.overdrawMetrics().recordMetrics(this);
 
     removeRenderPasses(CullRenderPassesWithNoQuads(), frame);
     m_renderer->decideRenderPassAllocationsForFrame(frame.renderPasses);
     removeRenderPasses(CullRenderPassesWithCachedTextures(*m_renderer), frame);
 
     return drawFrame;
 }
 
-void LayerTreeHostImpl::animateLayersRecursive(LayerImpl* current, double monotonicTime, double wallClockTime, AnimationEventsVector* events, bool& didAnimate, bool& needsAnimateLayers)
+void LayerTreeHostImpl::animateLayersRecursive(LayerImpl* current, base::TimeTicks monotonicTime, base::Time wallClockTime, AnimationEventsVector* events, bool& didAnimate, bool& needsAnimateLayers)
 {
     bool subtreeNeedsAnimateLayers = false;
 
     LayerAnimationController* currentController = current->layerAnimationController();
 
     bool hadActiveAnimation = currentController->hasActiveAnimation();
-    currentController->animate(monotonicTime, events);
+    double monotonicTimeSeconds = (monotonicTime - base::TimeTicks()).InSecondsF();
+    currentController->animate(monotonicTimeSeconds, events);
     bool startedAnimation = events->size() > 0;
 
     // We animated if we either ticked a running animation, or started a new animation.
     if (hadActiveAnimation || startedAnimation)
         didAnimate = true;
 
     // If the current controller still has an active animation, we must continue animating layers.
     if (currentController->hasActiveAnimation())
          subtreeNeedsAnimateLayers = true;
 
@@ skipping 162 matching lines @@
         return;
     m_managedMemoryPolicy = policy;
     enforceManagedMemoryPolicy(m_managedMemoryPolicy);
     // We always need to commit after changing the memory policy because the new
     // limit can result in more or less content having texture allocated for it.
     m_client->setNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::onVSyncParametersChanged(double monotonicTimebase, double intervalInSeconds)
 {
-    m_client->onVSyncParametersChanged(monotonicTimebase, intervalInSeconds);
+    base::TimeTicks timebase = base::TimeTicks::FromInternalValue(monotonicTimebase * base::Time::kMicrosecondsPerSecond);
+    base::TimeDelta interval = base::TimeDelta::FromMicroseconds(intervalInSeconds * base::Time::kMicrosecondsPerSecond);
+    m_client->onVSyncParametersChanged(timebase, interval);
 }
 
 void LayerTreeHostImpl::drawLayers(const FrameData& frame)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::drawLayers");
     DCHECK(canDraw());
     DCHECK(!frame.renderPasses.empty());
 
     // FIXME: use the frame begin time from the overall compositor scheduler.
     // This value is currently inaccessible because it is up in Chromium's
@@ skipping 682 matching lines @@
 
 void LayerTreeHostImpl::setFullRootLayerDamage()
 {
     if (m_rootLayerImpl) {
         RenderSurfaceImpl* renderSurface = m_rootLayerImpl->renderSurface();
         if (renderSurface)
             renderSurface->damageTracker()->forceFullDamageNextUpdate();
     }
 }
 
-void LayerTreeHostImpl::animatePageScale(double monotonicTime)
+void LayerTreeHostImpl::animatePageScale(base::TimeTicks time)
 {
     if (!m_pageScaleAnimation || !m_rootScrollLayerImpl)
         return;
 
+    double monotonicTime = (time - base::TimeTicks()).InSecondsF();
     IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());
 
     setPageScaleDelta(m_pageScaleAnimation->pageScaleAtTime(monotonicTime) / m_pinchZoomViewport.pageScaleFactor());
     IntSize nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(monotonicTime);
     nextScroll.scale(1 / m_pinchZoomViewport.pageScaleDelta());
     m_rootScrollLayerImpl->scrollBy(nextScroll - scrollTotal);
     m_client->setNeedsRedrawOnImplThread();
 
     if (m_pageScaleAnimation->isAnimationCompleteAtTime(monotonicTime)) {
         m_pageScaleAnimation.reset();
         m_client->setNeedsCommitOnImplThread();
     }
 }
 
-void LayerTreeHostImpl::animateLayers(double monotonicTime, double wallClockTime)
+void LayerTreeHostImpl::animateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime)
 {
     if (!Settings::acceleratedAnimationEnabled() || !m_needsAnimateLayers || !m_rootLayerImpl)
         return;
 
     TRACE_EVENT0("cc", "LayerTreeHostImpl::animateLayers");
 
     scoped_ptr<AnimationEventsVector> events(make_scoped_ptr(new AnimationEventsVector));
 
     bool didAnimate = false;
     animateLayersRecursive(m_rootLayerImpl.get(), monotonicTime, wallClockTime, events.get(), didAnimate, m_needsAnimateLayers);
@@ skipping 64 matching lines @@
 }
 
 void LayerTreeHostImpl::renderingStats(RenderingStats* stats) const
 {
     stats->numFramesSentToScreen = fpsCounter()->currentFrameNumber();
     stats->droppedFrameCount = fpsCounter()->droppedFrameCount();
     stats->numImplThreadScrolls = m_numImplThreadScrolls;
     stats->numMainThreadScrolls = m_numMainThreadScrolls;
 }
 
-void LayerTreeHostImpl::animateScrollbars(double monotonicTime)
+void LayerTreeHostImpl::animateScrollbars(base::TimeTicks time)
 {
-    animateScrollbarsRecursive(m_rootLayerImpl.get(), monotonicTime);
+    animateScrollbarsRecursive(m_rootLayerImpl.get(), time);
 }
 
-void LayerTreeHostImpl::animateScrollbarsRecursive(LayerImpl* layer, double monotonicTime)
+void LayerTreeHostImpl::animateScrollbarsRecursive(LayerImpl* layer, base::TimeTicks time)
 {
     if (!layer)
         return;
 
     ScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
+    double monotonicTime = (time - base::TimeTicks()).InSecondsF();
     if (scrollbarController && scrollbarController->animate(monotonicTime))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
-        animateScrollbarsRecursive(layer->children()[i], monotonicTime);
+        animateScrollbarsRecursive(layer->children()[i], time);
 }
 
 }  // namespace cc