cc: Delay start of scrollbar animation setNeedsRedraw.

cc/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/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 1374 matching lines @@
   // When hiding top controls is enabled and the controls are hidden or
   // overlaying the content, force scrolls to be enabled on the root layer to
   // allow bringing the top controls back into view.
   if (!potentially_scrolling_layer_impl && top_controls_manager_ &&
       top_controls_manager_->content_top_offset() !=
       settings_.topControlsHeight) {
     potentially_scrolling_layer_impl = RootScrollLayer();
   }
 
   if (potentially_scrolling_layer_impl) {
-    active_tree_->set_currently_scrolling_layer(
+    active_tree_->SetCurrentlyScrollingLayer(
         potentially_scrolling_layer_impl);
     should_bubble_scrolls_ = (type != NonBubblingGesture);
     wheel_scrolling_ = (type == Wheel);
     num_impl_thread_scrolls_++;
     client_->RenewTreePriority();
     UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
     active_tree()->DidBeginScroll();
     return ScrollStarted;
   }
   return ScrollIgnored;
@@ skipping 121 matching lines @@
     float move_threshold_squared = 0.1f * 0.1f;
     if (applied_delta.LengthSquared() < move_threshold_squared) {
       if (should_bubble_scrolls_ || !did_lock_scrolling_layer_)
         continue;
       else
         break;
     }
     did_scroll = true;
     did_lock_scrolling_layer_ = true;
     if (!should_bubble_scrolls_) {
-      active_tree_->set_currently_scrolling_layer(layer_impl);
+      active_tree_->SetCurrentlyScrollingLayer(layer_impl);
       break;
     }
 
     // If the applied delta is within 45 degrees of the input delta, bail out to
     // make it easier to scroll just one layer in one direction without
     // affecting any of its parents.
     float angle_threshold = 45;
     if (MathUtil::SmallestAngleBetweenVectors(
             applied_delta, pending_delta) < angle_threshold) {
       pending_delta = gfx::Vector2d();
@@ skipping 21 matching lines @@
 void LayerTreeHostImpl::ClearCurrentlyScrollingLayer() {
   active_tree_->ClearCurrentlyScrollingLayer();
   did_lock_scrolling_layer_ = false;
 }
 
 void LayerTreeHostImpl::ScrollEnd() {
   if (top_controls_manager_)
     top_controls_manager_->ScrollEnd();
   ClearCurrentlyScrollingLayer();
   active_tree()->DidEndScroll();
+  StartScrollbarAnimation(base::TimeTicks::Now());
 }
 
 void LayerTreeHostImpl::PinchGestureBegin() {
   pinch_gesture_active_ = true;
   previous_pinch_anchor_ = gfx::Point();
   client_->RenewTreePriority();
 }
 
 void LayerTreeHostImpl::PinchGestureUpdate(float magnify_delta,
                                            gfx::Point anchor) {
@@ skipping 12 matching lines @@
   gfx::PointF new_scale_anchor =
       gfx::ScalePoint(anchor, 1.f / page_scale_delta);
   gfx::Vector2dF move = previous_scale_anchor - new_scale_anchor;
 
   previous_pinch_anchor_ = anchor;
 
   move.Scale(1 / active_tree_->page_scale_factor());
 
   RootScrollLayer()->ScrollBy(move);
 
-  if (RootScrollLayer()->scrollbar_animation_controller()) {
-    RootScrollLayer()->scrollbar_animation_controller()->
-        didPinchGestureUpdate(base::TimeTicks::Now());
-  }
-
   client_->SetNeedsCommitOnImplThread();
   client_->SetNeedsRedrawOnImplThread();
   client_->RenewTreePriority();
 }
 
 void LayerTreeHostImpl::PinchGestureEnd() {
   pinch_gesture_active_ = false;
-
-  if (RootScrollLayer() &&
-      RootScrollLayer()->scrollbar_animation_controller()) {
-    RootScrollLayer()->scrollbar_animation_controller()->
-        didPinchGestureEnd(base::TimeTicks::Now());
-  }
-
   client_->SetNeedsCommitOnImplThread();
 }
 
 static void CollectScrollDeltas(ScrollAndScaleSet* scroll_info,
                                 LayerImpl* layer_impl) {
   if (!layer_impl)
     return;
 
   gfx::Vector2d scroll_delta =
       gfx::ToFlooredVector2d(layer_impl->scroll_delta());
@@ skipping 208 matching lines @@
   AnimateScrollbarsRecursive(active_tree_->root_layer(), time);
 }
 
 void LayerTreeHostImpl::AnimateScrollbarsRecursive(LayerImpl* layer,
                                                    base::TimeTicks time) {
   if (!layer)
     return;
 
   ScrollbarAnimationController* scrollbar_controller =
       layer->scrollbar_animation_controller();
-  if (scrollbar_controller && scrollbar_controller->animate(time))
+  if (scrollbar_controller && scrollbar_controller->animate(time)) {
+    TRACE_EVENT_INSTANT0(
+        "cc", "LayerTreeHostImpl::SetNeedsRedraw due to AnimateScrollbars");
     client_->SetNeedsRedrawOnImplThread();
+  }
 
   for (size_t i = 0; i < layer->children().size(); ++i)
     AnimateScrollbarsRecursive(layer->children()[i], time);
 }
 
+void LayerTreeHostImpl::StartScrollbarAnimation(base::TimeTicks time) {
+  TRACE_EVENT0("cc", "LayerTreeHostImpl::StartScrollbarAnimation");
+  StartScrollbarAnimationRecursive(RootLayer(), time);
+}
+
+void LayerTreeHostImpl::StartScrollbarAnimationRecursive(LayerImpl* layer,
+                                                         base::TimeTicks 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;
 
   GlobalStateThatImpactsTilePriority new_state(tile_manager_->GlobalState());
   if (new_state.tree_priority == priority)
     return;
 
   new_state.tree_priority = priority;
   tile_manager_->SetGlobalState(new_state);
@@ skipping 72 matching lines @@
     tile_manager_->SetRecordRenderingStats(debug_state_.recordRenderingStats());
 }
 
 void LayerTreeHostImpl::SavePaintTime(const base::TimeDelta& total_paint_time,
                                       int commit_number) {
   DCHECK(debug_state_.continuousPainting);
   paint_time_counter_->SavePaintTime(total_paint_time, commit_number);
 }
 
 }  // namespace cc