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

cc/layer_tree_host.h

 // 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.
 
 #ifndef CCLayerTreeHost_h
 #define CCLayerTreeHost_h
 
 #include <limits>
 
 #include "IntRect.h"
 #include "base/basictypes.h"
 #include "base/cancelable_callback.h"
 #include "base/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/time.h"
 #include "cc/animation_events.h"
 #include "cc/graphics_context.h"
 #include "cc/layer_tree_host_client.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/occlusion_tracker.h"
 #include "cc/prioritized_texture_manager.h"
 #include "cc/proxy.h"
 #include "cc/rate_limiter.h"
 #include "cc/rendering_stats.h"
 #include "cc/scoped_ptr_vector.h"
@@ skipping 73 matching lines @@
     // Returns true if any LayerTreeHost is alive.
     static bool anyLayerTreeHostInstanceExists();
 
     static bool needsFilterContext() { return s_needsFilterContext; }
     static void setNeedsFilterContext(bool needsFilterContext) { s_needsFilterContext = needsFilterContext; }
     bool needsSharedContext() const { return needsFilterContext() || settings().acceleratePainting; }
 
     // LayerTreeHost interface to Proxy.
     void willBeginFrame() { m_client->willBeginFrame(); }
     void didBeginFrame() { m_client->didBeginFrame(); }
-    void updateAnimations(double monotonicFrameBeginTime);
+    void updateAnimations(base::TimeTicks monotonicFrameBeginTime);
     void layout();
     void beginCommitOnImplThread(LayerTreeHostImpl*);
     void finishCommitOnImplThread(LayerTreeHostImpl*);
     void willCommit();
     void commitComplete();
     scoped_ptr<GraphicsContext> createContext();
     scoped_ptr<InputHandler> createInputHandler();
     virtual scoped_ptr<LayerTreeHostImpl> createLayerTreeHostImpl(LayerTreeHostImplClient*);
     void didLoseContext();
     enum RecreateResult {
@@ skipping 36 matching lines @@
 
     // Test only hook
     void loseContext(int numTimes);
 
     void setNeedsAnimate();
     // virtual for testing
     virtual void setNeedsCommit();
     void setNeedsRedraw();
     bool commitRequested() const;
 
-    void setAnimationEvents(scoped_ptr<AnimationEventsVector>, double wallClockTime);
+    void setAnimationEvents(scoped_ptr<AnimationEventsVector>, base::Time wallClockTime);
     virtual void didAddAnimation();
 
     Layer* rootLayer() { return m_rootLayer.get(); }
     const Layer* rootLayer() const { return m_rootLayer.get(); }
     void setRootLayer(scoped_refptr<Layer>);
 
     const LayerTreeSettings& settings() const { return m_settings; }
 
     void setViewportSize(const IntSize& layoutViewportSize, const IntSize& deviceViewportSize);
 
     const IntSize& layoutViewportSize() const { return m_layoutViewportSize; }
     const IntSize& deviceViewportSize() const { return m_deviceViewportSize; }
 
     void setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor);
 
     void setBackgroundColor(SkColor color) { m_backgroundColor = color; }
 
     void setHasTransparentBackground(bool transparent) { m_hasTransparentBackground = transparent; }
 
     PrioritizedTextureManager* contentsTextureManager() const;
 
     bool visible() const { return m_visible; }
     void setVisible(bool);
 
-    void startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double durationSec);
+    void startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, base::TimeDelta duration);
 
     void applyScrollAndScale(const ScrollAndScaleSet&);
     void setImplTransform(const WebKit::WebTransformationMatrix&);
 
     void startRateLimiter(WebKit::WebGraphicsContext3D*);
     void stopRateLimiter(WebKit::WebGraphicsContext3D*);
 
     // RateLimitClient implementation
     virtual void rateLimit() OVERRIDE;
 
@@ skipping 21 matching lines @@
     bool paintMasksForRenderSurface(Layer*, ResourceUpdateQueue&);
 
     void updateLayers(Layer*, ResourceUpdateQueue&);
     void triggerPrepaint();
 
     void prioritizeTextures(const LayerList&, OverdrawMetrics&); 
     void setPrioritiesForSurfaces(size_t surfaceMemoryBytes);
     void setPrioritiesForLayers(const LayerList&);
     size_t calculateMemoryForRenderSurfaces(const LayerList& updateList);
 
-    void animateLayers(double monotonicTime);
-    bool animateLayersRecursive(Layer* current, double monotonicTime);
-    void setAnimationEventsRecursive(const AnimationEventsVector&, Layer*, double wallClockTime);
+    void animateLayers(base::TimeTicks monotonicTime);
+    bool animateLayersRecursive(Layer* current, base::TimeTicks time);
+    void setAnimationEventsRecursive(const AnimationEventsVector&, Layer*, base::Time wallClockTime);
 
     bool m_animating;
     bool m_needsAnimateLayers;
 
     base::CancelableClosure m_prepaintCallback;
 
     LayerTreeHostClient* m_client;
 
     int m_commitNumber;
     RenderingStats m_renderingStats;
@@ skipping 34 matching lines @@
     size_t m_partialTextureUpdateRequests;
 
     static bool s_needsFilterContext;
 
     DISALLOW_COPY_AND_ASSIGN(LayerTreeHost);
 };
 
 }  // namespace cc
 
 #endif