gfx: Add FrameTime and DisplayTime classes

cc/trees/layer_tree_host_impl.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 CC_TREES_LAYER_TREE_HOST_IMPL_H_
 #define CC_TREES_LAYER_TREE_HOST_IMPL_H_
 
 #include <list>
 #include <set>
 #include <string>
@@ skipping 140 matching lines @@
     LayerImplList will_draw_layers;
     bool contains_incomplete_tile;
     bool has_no_damage;
 
     // RenderPassSink implementation.
     virtual void AppendRenderPass(scoped_ptr<RenderPass> render_pass) OVERRIDE;
   };
 
   virtual void BeginCommit();
   virtual void CommitComplete();
-  virtual void Animate(base::TimeTicks monotonic_time,
+  virtual void Animate(gfx::FrameTime monotonic_time,
                        base::Time wall_clock_time);
   virtual void UpdateAnimationState(bool start_ready_animations);
   void MainThreadHasStoppedFlinging();
   void UpdateBackgroundAnimateTicking(bool should_background_tick);
   void SetViewportDamage(gfx::Rect damage_rect);
 
   virtual void ManageTiles();
 
   // Returns false if problems occured preparing the frame, and we should try
   // to avoid displaying the frame. If PrepareToDraw is called, DidDrawAllLayers
   // must also be called, regardless of whether DrawLayers is called between the
   // two.
   virtual bool PrepareToDraw(FrameData* frame,
                              gfx::Rect device_viewport_damage_rect);
-  virtual void DrawLayers(FrameData* frame, base::TimeTicks frame_begin_time);
+  virtual void DrawLayers(FrameData* frame, gfx::FrameTime frame_begin_time);
   // Must be called if and only if PrepareToDraw was called.
   void DidDrawAllLayers(const FrameData& frame);
 
   const LayerTreeSettings& settings() const { return settings_; }
 
   // Evict all textures by enforcing a memory policy with an allocation of 0.
   void EvictTexturesForTesting();
 
   // When blocking, this prevents client_->NotifyReadyToActivate() from being
   // called. When disabled, it calls client_->NotifyReadyToActivate()
@@ skipping 187 matching lines @@
   }
   gfx::Vector2dF current_fling_velocity() const {
     return current_fling_velocity_;
   }
 
   bool pinch_gesture_active() const { return pinch_gesture_active_; }
 
   void SetTreePriority(TreePriority priority);
 
   void ResetCurrentFrameTimeForNextFrame();
-  virtual base::TimeTicks CurrentFrameTimeTicks();
+  virtual gfx::FrameTime CurrentFrameTimeTicks();
   base::Time CurrentFrameTime();
 
-  virtual base::TimeTicks CurrentPhysicalTimeTicks() const;
+  virtual gfx::FrameTime CurrentPhysicalFrameTime() const;
 
   scoped_ptr<base::Value> AsValue() const { return AsValueWithFrame(NULL); }
   scoped_ptr<base::Value> AsValueWithFrame(FrameData* frame) const;
   scoped_ptr<base::Value> ActivationStateAsValue() const;
 
   bool page_scale_animation_active() const { return !!page_scale_animation_; }
 
   virtual void CreateUIResource(UIResourceId uid,
                                 const UIResourceBitmap& bitmap);
   // Deletes a UI resource.  May safely be called more than once.
@@ skipping 11 matching lines @@
 
  protected:
   LayerTreeHostImpl(
       const LayerTreeSettings& settings,
       LayerTreeHostImplClient* client,
       Proxy* proxy,
       RenderingStatsInstrumentation* rendering_stats_instrumentation,
       SharedBitmapManager* manager);
 
   // Virtual for testing.
-  virtual void AnimateLayers(base::TimeTicks monotonic_time,
+  virtual void AnimateLayers(gfx::FrameTime monotonic_time,
                              base::Time wall_clock_time);
 
   // Virtual for testing.
   virtual base::TimeDelta LowFrequencyAnimationInterval() const;
 
   const AnimationRegistrar::AnimationControllerMap&
       active_animation_controllers() const {
     return animation_registrar_->active_animation_controllers();
   }
 
   bool manage_tiles_needed() const { return tile_priorities_dirty_; }
 
   LayerTreeHostImplClient* client_;
   Proxy* proxy_;
 
  private:
   void CreateAndSetRenderer(
       OutputSurface* output_surface,
       ResourceProvider* resource_provider,
       bool skip_gl_renderer);
   void CreateAndSetTileManager(ResourceProvider* resource_provider,
                                ContextProvider* context_provider,
                                bool using_map_image);
   void ReleaseTreeResources();
   void EnforceZeroBudget(bool zero_budget);
 
-  void AnimatePageScale(base::TimeTicks monotonic_time);
-  void AnimateScrollbars(base::TimeTicks monotonic_time);
-  void AnimateTopControls(base::TimeTicks monotonic_time);
+  void AnimatePageScale(gfx::FrameTime monotonic_time);
+  void AnimateScrollbars(gfx::FrameTime monotonic_time);
+  void AnimateTopControls(gfx::FrameTime monotonic_time);
 
   gfx::Vector2dF ScrollLayerWithViewportSpaceDelta(
       LayerImpl* layer_impl,
       float scale_from_viewport_to_screen_space,
       gfx::PointF viewport_point,
       gfx::Vector2dF viewport_delta);
 
   void UpdateMaxScrollOffset();
   void TrackDamageForAllSurfaces(
       LayerImpl* root_draw_layer,
       const LayerImplList& render_surface_layer_list);
 
   void UpdateTileManagerMemoryPolicy(const ManagedMemoryPolicy& policy);
 
   // Returns false if the frame should not be displayed. This function should
   // only be called from PrepareToDraw, as DidDrawAllLayers must be called
   // if this helper function is called.
   bool CalculateRenderPasses(FrameData* frame);
 
   void SendReleaseResourcesRecursive(LayerImpl* current);
   bool EnsureRenderSurfaceLayerList();
   void ClearCurrentlyScrollingLayer();
 
   bool HandleMouseOverScrollbar(LayerImpl* layer_impl,
                                 gfx::PointF device_viewport_point);
 
   void AnimateScrollbarsRecursive(LayerImpl* layer,
-                                  base::TimeTicks time);
+                                  gfx::FrameTime time);
 
-  void UpdateCurrentFrameTime(base::TimeTicks* ticks, base::Time* now) const;
+  void UpdateCurrentFrameTime(gfx::FrameTime *ticks, base::Time* now) const;
 
   LayerImpl* FindScrollLayerForDeviceViewportPoint(
       gfx::PointF device_viewport_point,
       InputHandler::ScrollInputType type,
       LayerImpl* layer_hit_by_point,
       bool* scroll_on_main_thread) const;
   float DeviceSpaceDistanceToLayer(gfx::PointF device_viewport_point,
                                    LayerImpl* layer_impl);
-  void StartScrollbarAnimationRecursive(LayerImpl* layer, base::TimeTicks time);
+  void StartScrollbarAnimationRecursive(LayerImpl* layer,
+                                        gfx::FrameTime time);
   void SetManagedMemoryPolicy(const ManagedMemoryPolicy& policy,
                               bool zero_budget);
   void EnforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy);
 
   void DidInitializeVisibleTile();
 
   void MarkUIResourceNotEvicted(UIResourceId uid);
 
   typedef base::hash_map<UIResourceId, UIResourceData>
       UIResourceMap;
@@ skipping 105 matching lines @@
   // (When these are specified, device_viewport_size_ remains used only for
   // scrollable size.)
   gfx::Transform external_transform_;
   gfx::Rect external_viewport_;
   gfx::Rect external_clip_;
   bool device_viewport_valid_for_tile_management_;
   bool external_stencil_test_enabled_;
 
   gfx::Rect viewport_damage_rect_;
 
-  base::TimeTicks current_frame_timeticks_;
+  gfx::FrameTime current_frame_timeticks_;
   base::Time current_frame_time_;
 
   scoped_ptr<AnimationRegistrar> animation_registrar_;
 
   RenderingStatsInstrumentation* rendering_stats_instrumentation_;
 
   bool need_to_update_visible_tiles_before_draw_;
 
   // Optional callback to notify of new tree activations.
   base::Closure tree_activation_callback_;
 
   SharedBitmapManager* shared_bitmap_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImpl);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_IMPL_H_