gfx: Add FrameTime and DisplayTime classes

cc/trees/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 "cc/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 124 matching lines @@
           new DebugScopedSetImplThread(layer_tree_host_impl_->proxy()));
     }
 
     // TODO(enne): This should probably happen post-animate.
     if (layer_tree_host_impl_->pending_tree()) {
       layer_tree_host_impl_->pending_tree()->UpdateDrawProperties();
       layer_tree_host_impl_->ManageTiles();
     }
 
     layer_tree_host_impl_->Animate(
-        layer_tree_host_impl_->CurrentFrameTimeTicks(),
+        gfx::FrameTime::Now(),
         layer_tree_host_impl_->CurrentFrameTime());
     layer_tree_host_impl_->UpdateBackgroundAnimateTicking(true);
     bool start_ready_animations = true;
     layer_tree_host_impl_->UpdateAnimationState(start_ready_animations);
     layer_tree_host_impl_->ResetCurrentFrameTimeForNextFrame();
   }
 
   void SetActive(bool active) {
     if (active != time_source_->Active())
       time_source_->SetActive(active);
@@ skipping 187 matching lines @@
   }
   if (EvictedUIResourcesExist()) {
     TRACE_EVENT_INSTANT0(
         "cc", "LayerTreeHostImpl::CanDraw UI resources evicted not recreated",
         TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
   return true;
 }
 
-void LayerTreeHostImpl::Animate(base::TimeTicks monotonic_time,
+void LayerTreeHostImpl::Animate(gfx::FrameTime monotonic_time,
                                 base::Time wall_clock_time) {
   if (input_handler_client_)
     input_handler_client_->Animate(monotonic_time);
   AnimatePageScale(monotonic_time);
   AnimateLayers(monotonic_time, wall_clock_time);
   AnimateScrollbars(monotonic_time);
   AnimateTopControls(monotonic_time);
 }
 
 void LayerTreeHostImpl::ManageTiles() {
@@ skipping 877 matching lines @@
   metadata.root_scroll_offset = RootScrollLayer()->TotalScrollOffset();
 
   return metadata;
 }
 
 static void LayerTreeHostImplDidBeginTracingCallback(LayerImpl* layer) {
   layer->DidBeginTracing();
 }
 
 void LayerTreeHostImpl::DrawLayers(FrameData* frame,
-                                   base::TimeTicks frame_begin_time) {
+                                   gfx::FrameTime  frame_begin_time) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::DrawLayers");
   DCHECK(CanDraw());
 
   if (frame->has_no_damage) {
     TRACE_EVENT0("cc", "EarlyOut_NoDamage");
     DCHECK(!output_surface_->capabilities()
                .draw_and_swap_full_viewport_every_frame);
     return;
   }
 
@@ skipping 1046 matching lines @@
     return;
 
   if (scroll_layer_id_when_mouse_over_scrollbar_) {
     LayerImpl* scroll_layer_impl = active_tree_->LayerById(
         scroll_layer_id_when_mouse_over_scrollbar_);
 
     ScrollbarAnimationController* animation_controller =
         scroll_layer_impl->scrollbar_animation_controller();
     if (animation_controller) {
       animation_controller->DidMouseMoveOffScrollbar(
-          CurrentPhysicalTimeTicks());
+          CurrentPhysicalFrameTime());
       StartScrollbarAnimation();
     }
     scroll_layer_id_when_mouse_over_scrollbar_ = 0;
   }
 
   bool scroll_on_main_thread = false;
   LayerImpl* scroll_layer_impl = FindScrollLayerForDeviceViewportPoint(
       device_viewport_point, InputHandler::Gesture, layer_impl,
       &scroll_on_main_thread);
   if (scroll_on_main_thread || !scroll_layer_impl)
     return;
 
   ScrollbarAnimationController* animation_controller =
       scroll_layer_impl->scrollbar_animation_controller();
   if (!animation_controller)
     return;
 
   float distance_to_scrollbar = std::min(
       DeviceSpaceDistanceToLayer(device_viewport_point,
           scroll_layer_impl->horizontal_scrollbar_layer()),
       DeviceSpaceDistanceToLayer(device_viewport_point,
           scroll_layer_impl->vertical_scrollbar_layer()));
 
   bool should_animate = animation_controller->DidMouseMoveNear(
-      CurrentPhysicalTimeTicks(), distance_to_scrollbar / device_scale_factor_);
+      CurrentPhysicalFrameTime(), distance_to_scrollbar / device_scale_factor_);
   if (should_animate) {
     client_->SetNeedsRedrawOnImplThread();
     StartScrollbarAnimation();
   }
 }
 
 bool LayerTreeHostImpl::HandleMouseOverScrollbar(LayerImpl* layer_impl,
     gfx::PointF device_viewport_point) {
   if (layer_impl && layer_impl->ToScrollbarLayer()) {
     int scroll_layer_id = layer_impl->ToScrollbarLayer()->ScrollLayerId();
     layer_impl = active_tree_->LayerById(scroll_layer_id);
     if (layer_impl && layer_impl->scrollbar_animation_controller()) {
       scroll_layer_id_when_mouse_over_scrollbar_ = scroll_layer_id;
       layer_impl->scrollbar_animation_controller()->DidMouseMoveNear(
-          CurrentPhysicalTimeTicks(), 0);
+          CurrentPhysicalFrameTime(), 0);
     } else {
       scroll_layer_id_when_mouse_over_scrollbar_ = 0;
     }
 
     return true;
   }
 
   return false;
 }
 
@@ skipping 69 matching lines @@
   scroll_info->page_scale_delta = active_tree_->page_scale_delta();
   active_tree_->set_sent_page_scale_delta(scroll_info->page_scale_delta);
 
   return scroll_info.Pass();
 }
 
 void LayerTreeHostImpl::SetFullRootLayerDamage() {
   SetViewportDamage(gfx::Rect(DrawViewportSize()));
 }
 
-void LayerTreeHostImpl::AnimatePageScale(base::TimeTicks time) {
+void LayerTreeHostImpl::AnimatePageScale(gfx::FrameTime time) {
   if (!page_scale_animation_ || !RootScrollLayer())
     return;
 
-  double monotonic_time = (time - base::TimeTicks()).InSecondsF();
+  double monotonic_time = time.Unsafe_InSecondsF();
   gfx::Vector2dF scroll_total = RootScrollLayer()->scroll_offset() +
                                 RootScrollLayer()->ScrollDelta();
 
   if (!page_scale_animation_->IsAnimationStarted())
     page_scale_animation_->StartAnimation(monotonic_time);
 
   active_tree_->SetPageScaleDelta(
       page_scale_animation_->PageScaleFactorAtTime(monotonic_time) /
       active_tree_->page_scale_factor());
   gfx::Vector2dF next_scroll =
       page_scale_animation_->ScrollOffsetAtTime(monotonic_time);
 
   RootScrollLayer()->ScrollBy(next_scroll - scroll_total);
   client_->SetNeedsRedrawOnImplThread();
 
   if (page_scale_animation_->IsAnimationCompleteAtTime(monotonic_time)) {
     page_scale_animation_.reset();
     client_->SetNeedsCommitOnImplThread();
     client_->RenewTreePriority();
   }
 }
 
-void LayerTreeHostImpl::AnimateTopControls(base::TimeTicks time) {
+void LayerTreeHostImpl::AnimateTopControls(gfx::FrameTime time) {
   if (!top_controls_manager_ || !RootScrollLayer())
     return;
   gfx::Vector2dF scroll = top_controls_manager_->Animate(time);
   UpdateMaxScrollOffset();
   if (RootScrollLayer()->TotalScrollOffset().y() == 0.f)
     return;
   RootScrollLayer()->ScrollBy(gfx::ScaleVector2d(
       scroll, 1.f / active_tree_->total_page_scale_factor()));
 }
 
-void LayerTreeHostImpl::AnimateLayers(base::TimeTicks monotonic_time,
+void LayerTreeHostImpl::AnimateLayers(gfx::FrameTime monotonic_time,
                                       base::Time wall_clock_time) {
   if (!settings_.accelerated_animation_enabled ||
       animation_registrar_->active_animation_controllers().empty() ||
       !active_tree_->root_layer())
     return;
 
   TRACE_EVENT0("cc", "LayerTreeHostImpl::AnimateLayers");
 
   last_animation_time_ = wall_clock_time;
-  double monotonic_seconds = (monotonic_time - base::TimeTicks()).InSecondsF();
+  double monotonic_seconds = monotonic_time.Unsafe_InSecondsF();
 
   AnimationRegistrar::AnimationControllerMap copy =
       animation_registrar_->active_animation_controllers();
   for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
        iter != copy.end();
        ++iter)
     (*iter).second->Animate(monotonic_seconds);
 
   client_->SetNeedsRedrawOnImplThread();
 }
@@ skipping 87 matching lines @@
   }
   last_sent_memory_visible_bytes_ = memory_visible_bytes;
   last_sent_memory_visible_and_nearby_bytes_ = memory_visible_and_nearby_bytes;
   last_sent_memory_use_bytes_ = memory_use_bytes;
 
   renderer_->SendManagedMemoryStats(last_sent_memory_visible_bytes_,
                                     last_sent_memory_visible_and_nearby_bytes_,
                                     last_sent_memory_use_bytes_);
 }
 
-void LayerTreeHostImpl::AnimateScrollbars(base::TimeTicks time) {
+void LayerTreeHostImpl::AnimateScrollbars(gfx::FrameTime time) {
   AnimateScrollbarsRecursive(active_tree_->root_layer(), time);
 }
 
 void LayerTreeHostImpl::AnimateScrollbarsRecursive(LayerImpl* layer,
-                                                   base::TimeTicks time) {
+                                                   gfx::FrameTime time) {
   if (!layer)
     return;
 
   ScrollbarAnimationController* scrollbar_controller =
       layer->scrollbar_animation_controller();
   if (scrollbar_controller && scrollbar_controller->Animate(time)) {
     TRACE_EVENT_INSTANT0(
         "cc", "LayerTreeHostImpl::SetNeedsRedraw due to AnimateScrollbars",
         TRACE_EVENT_SCOPE_THREAD);
     client_->SetNeedsRedrawOnImplThread();
   }
 
   for (size_t i = 0; i < layer->children().size(); ++i)
     AnimateScrollbarsRecursive(layer->children()[i], time);
 }
 
 void LayerTreeHostImpl::StartScrollbarAnimation() {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::StartScrollbarAnimation");
-  StartScrollbarAnimationRecursive(RootLayer(), CurrentPhysicalTimeTicks());
+  StartScrollbarAnimationRecursive(RootLayer(), CurrentFrameTimeTicks());
 }
 
 void LayerTreeHostImpl::StartScrollbarAnimationRecursive(LayerImpl* layer,
-                                                         base::TimeTicks time) {
+                                                         gfx::FrameTime time) {
   if (!layer)
     return;
 
   ScrollbarAnimationController* scrollbar_controller =
       layer->scrollbar_animation_controller();
   if (scrollbar_controller && scrollbar_controller->IsAnimating()) {
     base::TimeDelta delay = scrollbar_controller->DelayBeforeStart(time);
     if (delay > base::TimeDelta())
       client_->RequestScrollbarAnimationOnImplThread(delay);
     else if (scrollbar_controller->Animate(time))
       client_->SetNeedsRedrawOnImplThread();
   }
 
   for (size_t i = 0; i < layer->children().size(); ++i)
     StartScrollbarAnimationRecursive(layer->children()[i], time);
 }
 
 void LayerTreeHostImpl::SetTreePriority(TreePriority priority) {
   if (!tile_manager_)
     return;
 
   if (global_tile_state_.tree_priority == priority)
     return;
   global_tile_state_.tree_priority = priority;
   DidModifyTilePriorities();
 }
 
 void LayerTreeHostImpl::ResetCurrentFrameTimeForNextFrame() {
-  current_frame_timeticks_ = base::TimeTicks();
+  current_frame_timeticks_ = gfx::FrameTime();
   current_frame_time_ = base::Time();
 }
 
-void LayerTreeHostImpl::UpdateCurrentFrameTime(base::TimeTicks* ticks,
+void LayerTreeHostImpl::UpdateCurrentFrameTime(gfx::FrameTime* ticks,
                                                base::Time* now) const {
   if (ticks->is_null()) {
     DCHECK(now->is_null());
-    *ticks = CurrentPhysicalTimeTicks();
+    *ticks = gfx::FrameTime::Now();
     *now = base::Time::Now();
   }
 }
 
-base::TimeTicks LayerTreeHostImpl::CurrentFrameTimeTicks() {
+gfx::FrameTime LayerTreeHostImpl::CurrentFrameTimeTicks() {
   UpdateCurrentFrameTime(&current_frame_timeticks_, &current_frame_time_);
   return current_frame_timeticks_;
 }
 
 base::Time LayerTreeHostImpl::CurrentFrameTime() {
   UpdateCurrentFrameTime(&current_frame_timeticks_, &current_frame_time_);
   return current_frame_time_;
 }
 
-base::TimeTicks LayerTreeHostImpl::CurrentPhysicalTimeTicks() const {
+gfx::FrameTime LayerTreeHostImpl::CurrentPhysicalFrameTime() const {
   return gfx::FrameTime::Now();
 }
 
 scoped_ptr<base::Value> LayerTreeHostImpl::AsValueWithFrame(
     FrameData* frame) const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   if (this->pending_tree_)
       state->Set("activation_state", ActivationStateAsValue().release());
   state->Set("device_viewport_size",
              MathUtil::AsValue(device_viewport_size_).release());
@@ skipping 110 matching lines @@
   std::set<UIResourceId>::iterator found_in_evicted =
       evicted_ui_resources_.find(uid);
   if (found_in_evicted == evicted_ui_resources_.end())
     return;
   evicted_ui_resources_.erase(found_in_evicted);
   if (evicted_ui_resources_.empty())
     client_->OnCanDrawStateChanged(CanDraw());
 }
 
 }  // namespace cc