Fix scrollbar fade animation scheduling.

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 "base/basictypes.h"
 #include "base/json/json_writer.h"
@@ skipping 1909 matching lines @@
   active_tree_->ClearCurrentlyScrollingLayer();
   did_lock_scrolling_layer_ = false;
   accumulated_root_overscroll_ = gfx::Vector2dF();
   current_fling_velocity_ = gfx::Vector2dF();
 }
 
 void LayerTreeHostImpl::ScrollEnd() {
   if (top_controls_manager_)
     top_controls_manager_->ScrollEnd();
   ClearCurrentlyScrollingLayer();
-  StartScrollbarAnimation(CurrentFrameTimeTicks());
+  StartScrollbarAnimation();
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::FlingScrollBegin() {
   if (active_tree_->CurrentlyScrollingLayer())
     return ScrollStarted;
 
   return ScrollIgnored;
 }
 
 void LayerTreeHostImpl::NotifyCurrentFlingVelocity(gfx::Vector2dF velocity) {
@@ skipping 251 matching lines @@
     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(base::TimeTicks time) {
+void LayerTreeHostImpl::StartScrollbarAnimation() {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::StartScrollbarAnimation");
-  StartScrollbarAnimationRecursive(RootLayer(), time);
+  StartScrollbarAnimationRecursive(RootLayer(), CurrentPhysicalTimeTicks());
 }
 
 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 19 matching lines @@
   new_state.tree_priority = priority;
   tile_manager_->SetGlobalState(new_state);
   manage_tiles_needed_ = true;
 }
 
 void LayerTreeHostImpl::ResetCurrentFrameTimeForNextFrame() {
   current_frame_timeticks_ = base::TimeTicks();
   current_frame_time_ = base::Time();
 }
 
-static void UpdateCurrentFrameTime(base::TimeTicks* ticks, base::Time* now) {
+void LayerTreeHostImpl::UpdateCurrentFrameTime(base::TimeTicks* ticks,
+                                               base::Time* now) const {
   if (ticks->is_null()) {
     DCHECK(now->is_null());
-    *ticks = base::TimeTicks::Now();
+    *ticks = CurrentPhysicalTimeTicks();
     *now = base::Time::Now();
   }
 }
 
 base::TimeTicks 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 {

[danakj, 2013/06/14 18:35:10]

Think I'd prefer this is virtual instead of adding test data to the prod class.

+  if (!fake_current_physical_time_for_test_.is_null())
+    return fake_current_physical_time_for_test_;
+  else
+    return base::TimeTicks::Now();
+}
+
+void LayerTreeHostImpl::SetCurrentPhysicalTimeTicksForTest(
+    base::TimeTicks fake_time) {
+  fake_current_physical_time_for_test_ = fake_time;
+}
+
 scoped_ptr<base::Value> LayerTreeHostImpl::AsValue() 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_)
     state->Set("tiles", tile_manager_->AllTilesAsValue().release());
   state->Set("active_tree", active_tree_->AsValue().release());
   if (pending_tree_)
@@ skipping 36 matching lines @@
 }
 
 void LayerTreeHostImpl::SetDebugState(const LayerTreeDebugState& debug_state) {
   if (debug_state_.continuous_painting != debug_state.continuous_painting)
     paint_time_counter_->ClearHistory();
 
   debug_state_ = debug_state;
 }
 
 }  // namespace cc