Change LayerHostImpl to use frame time from BeginFrameArgs rather than ::Now()

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 149 matching lines @@
       set_impl_thread.reset(
           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();
     }
 
+    // TODO(mithro): Change to using something like
+    // OnBackgroundFrame(BeginFrameArgs xxx)
+    layer_tree_host_impl_->OverrideCurrentFrameTime(

[danakj, 2014/03/11 18:32:36]

This should be above UpdateDrawProps/ManageTiles.

+        time_source_->LastTickTime());
     layer_tree_host_impl_->Animate(
         layer_tree_host_impl_->CurrentFrameTimeTicks());
     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);
   }
 
   bool Active() const { return time_source_->Active(); }
 
  private:
@@ skipping 1097 matching lines @@
 }
 
 void LayerTreeHostImpl::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
   if (damage_rect.IsEmpty())
     return;
   NotifySwapPromiseMonitorsOfSetNeedsRedraw();
   client_->SetNeedsRedrawRectOnImplThread(damage_rect);
 }
 
 void LayerTreeHostImpl::BeginImplFrame(const BeginFrameArgs& args) {
+  last_frame_args_ = current_frame_args_;
+  current_frame_args_ = args;
+
   client_->BeginImplFrame(args);
 }
 
 void LayerTreeHostImpl::DidSwapBuffers() {
   client_->DidSwapBuffersOnImplThread();
 }
 
 void LayerTreeHostImpl::OnSwapBuffersComplete() {
   client_->OnSwapBuffersCompleteOnImplThread();
 }
@@ skipping 1160 matching lines @@
     LayerImpl* scroll_layer_impl = active_tree_->LayerById(
         scroll_layer_id_when_mouse_over_scrollbar_);
 
     // The check for a null scroll_layer_impl below was added to see if it will
     // eliminate the crashes described in http://crbug.com/326635.
     // TODO(wjmaclean) Add a unit test if this fixes the crashes.
     ScrollbarAnimationController* animation_controller =
         scroll_layer_impl ? scroll_layer_impl->scrollbar_animation_controller()
                           : NULL;
     if (animation_controller) {
-      animation_controller->DidMouseMoveOffScrollbar(
-          CurrentPhysicalTimeTicks());
+      animation_controller->DidMouseMoveOffScrollbar(CurrentFrameTimeTicks());

[aelias_OOO_until_Jul13, 2014/03/21 01:37:44]

physical time

       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;
 
   // TODO(wjmaclean) Is it ok to choose distance from more than two scrollbars?
   float distance_to_scrollbar = std::numeric_limits<float>::max();
   for (LayerImpl::ScrollbarSet::iterator it =
            scroll_layer_impl->scrollbars()->begin();
        it != scroll_layer_impl->scrollbars()->end();
        ++it)
     distance_to_scrollbar =
         std::min(distance_to_scrollbar,
                  DeviceSpaceDistanceToLayer(device_viewport_point, *it));
 
+  // TODO(mithro): Show this be something other then frame time?
   bool should_animate = animation_controller->DidMouseMoveNear(
-      CurrentPhysicalTimeTicks(), distance_to_scrollbar / device_scale_factor_);
+      CurrentFrameTimeTicks(), distance_to_scrollbar / device_scale_factor_);

[danakj, 2014/03/11 18:32:36]

What happens if you get input here and you're not in a BeginImplFrame yet, or
the impl frame takes multiple vsyncs? Is this going to cause any regressions?
+aelias for thoughts on CurrentPhysical -> CurrentFrame time.

   if (should_animate)
     StartScrollbarAnimation();
 }
 
 bool LayerTreeHostImpl::HandleMouseOverScrollbar(LayerImpl* layer_impl,
     const 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;
       bool should_animate =
           layer_impl->scrollbar_animation_controller()->DidMouseMoveNear(
-              CurrentPhysicalTimeTicks(), 0);
+              CurrentFrameTimeTicks(), 0);

[aelias_OOO_until_Jul13, 2014/03/21 01:37:44]

physical time

       if (should_animate)
         StartScrollbarAnimation();
     } else {
       scroll_layer_id_when_mouse_over_scrollbar_ = 0;
     }
 
     return true;
   }
 
   return false;
@@ skipping 295 matching lines @@
         TRACE_EVENT_SCOPE_THREAD);
     SetNeedsRedraw();
   }
 
   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());

[aelias_OOO_until_Jul13, 2014/03/21 01:37:44]

This is another thing I specifically changed to physical time in
https://chromiumcodereview.appspot.com/16925007

 }
 
 void LayerTreeHostImpl::StartScrollbarAnimationRecursive(LayerImpl* layer,
                                                          base::TimeTicks time) {
   if (!layer)
     return;
 
   ScrollbarAnimationController* scrollbar_controller =
       layer->scrollbar_animation_controller();
   if (scrollbar_controller && scrollbar_controller->IsAnimating()) {
@@ skipping 11 matching lines @@
 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();
+void LayerTreeHostImpl::OverrideCurrentFrameTime(base::TimeTicks frame_time) {
+  TRACE_EVENT1("cc",
+               "LayerTreeHostImpl::OverrideCurrentFrameTime",
+               "frame_time",
+               frame_time.ToInternalValue());
+  current_frame_args_.frame_time = frame_time;
 }
 
-void LayerTreeHostImpl::UpdateCurrentFrameTime(base::TimeTicks* ticks) const {
-  if (ticks->is_null()) {
-    *ticks = CurrentPhysicalTimeTicks();
-  }
-}
-
-base::TimeTicks LayerTreeHostImpl::CurrentFrameTimeTicks() {
-  UpdateCurrentFrameTime(&current_frame_timeticks_);
-  return current_frame_timeticks_;
-}
-
-base::TimeTicks LayerTreeHostImpl::CurrentPhysicalTimeTicks() const {
-  return gfx::FrameTime::Now();
+base::TimeTicks LayerTreeHostImpl::CurrentFrameTimeTicks() const {
+  return current_frame_args_.frame_time;
 }
 
 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());
   if (tile_manager_)
@@ skipping 138 matching lines @@
   swap_promise_monitor_.erase(monitor);
 }
 
 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfSetNeedsRedraw() {
   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnSetNeedsRedrawOnImpl();
 }
 
 }  // namespace cc