[Android]Increase Scrollbar fade delay on Resize.

cc/layers/layer_impl.cc

 // Copyright 2012 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/layers/layer_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_argument.h"
 #include "base/json/json_reader.h"
 #include "base/strings/stringprintf.h"
@@ skipping 764 matching lines @@
   return gfx::ToCeiledSize(gfx::SizeF(bounds_.width() + bounds_delta_.x(),
                                       bounds_.height() + bounds_delta_.y()));
 }
 
 void LayerImpl::SetBounds(const gfx::Size& bounds) {
   if (bounds_ == bounds)
     return;
 
   bounds_ = bounds;
 
-  ScrollbarParametersDidChange();
+  ScrollbarParametersDidChange(true);
   if (masks_to_bounds())
     NoteLayerPropertyChangedForSubtree();
   else
     NoteLayerPropertyChanged();
 }
 
 void LayerImpl::SetBoundsDelta(const gfx::Vector2dF& bounds_delta) {
   if (bounds_delta_ == bounds_delta)
     return;
 
   bounds_delta_ = bounds_delta;
 
-  ScrollbarParametersDidChange();
+  ScrollbarParametersDidChange(false);
   if (masks_to_bounds())
     NoteLayerPropertyChangedForSubtree();
   else
     NoteLayerPropertyChanged();
 }
 
 void LayerImpl::SetMaskLayer(scoped_ptr<LayerImpl> mask_layer) {
   int new_layer_id = mask_layer ? mask_layer->id() : -1;
 
   if (mask_layer) {
@@ skipping 306 matching lines @@
     if (scroll_offset_delegate_) {
       scroll_offset_delegate_->SetTotalScrollOffset(
           ScrollOffsetWithDelta(scroll_offset_, scroll_delta));
     } else {
       scroll_delta_ = scroll_delta;
     }
   }
 
   if (changed) {
     NoteLayerPropertyChangedForSubtree();
-    ScrollbarParametersDidChange();
+    ScrollbarParametersDidChange(false);
   }
 }
 
 gfx::Vector2dF LayerImpl::ScrollDelta() const {
   if (scroll_offset_delegate_) {
     return scroll_offset_delegate_->GetTotalScrollOffset().DeltaFrom(
         scroll_offset_);
   }
   return scroll_delta_;
 }
@@ skipping 85 matching lines @@
   clamped_offset.SetToMin(max_offset);
   clamped_offset.SetToMax(gfx::ScrollOffset());
   gfx::Vector2dF delta = clamped_offset.DeltaFrom(old_offset);
   if (!delta.IsZero())
     ScrollBy(delta);
 
   return delta;
 }
 
 void LayerImpl::SetScrollbarPosition(ScrollbarLayerImplBase* scrollbar_layer,
-                                     LayerImpl* scrollbar_clip_layer) const {
+                                     LayerImpl* scrollbar_clip_layer,
+                                     bool on_resize) const {
   DCHECK(scrollbar_layer);
   LayerImpl* page_scale_layer = layer_tree_impl()->page_scale_layer();
 
   DCHECK(this != page_scale_layer);
   DCHECK(scrollbar_clip_layer);
   DCHECK(this != layer_tree_impl()->InnerViewportScrollLayer() ||
          IsContainerForFixedPositionLayers());
   gfx::RectF clip_rect(gfx::PointF(), scrollbar_clip_layer->bounds());
 
   // See comment in MaxScrollOffset() regarding the use of the content layer
@@ skipping 64 matching lines @@
     if (scrollbar_animation_controller_) {
       // When both non-overlay and overlay scrollbars are both present, don't
       // animate the overlay scrollbars when page scale factor is at the min.
       // Non-overlay scrollbars also shouldn't trigger animations.
       bool is_animatable_scrollbar =
           scrollbar_layer->is_overlay_scrollbar() &&
           ((layer_tree_impl()->total_page_scale_factor() >
             layer_tree_impl()->min_page_scale_factor()) ||
            !layer_tree_impl()->settings().use_pinch_zoom_scrollbars);
       if (is_animatable_scrollbar)
-        scrollbar_animation_controller_->DidScrollUpdate();
+        scrollbar_animation_controller_->DidScrollUpdate(on_resize);
     }
   }
 }
 
 void LayerImpl::DidBecomeActive() {
   if (layer_tree_impl_->settings().scrollbar_animator ==
       LayerTreeSettings::NoAnimator) {
     return;
   }
 
@@ skipping 42 matching lines @@
 
   for (ScrollbarSet::iterator it = scrollbars_->begin();
        it != scrollbars_->end();
        ++it)
     if ((*it)->orientation() == orientation)
       return true;
 
   return false;
 }
 
-void LayerImpl::ScrollbarParametersDidChange() {
+void LayerImpl::ScrollbarParametersDidChange(bool on_resize) {
   if (!scrollbars_)
     return;
 
   for (ScrollbarSet::iterator it = scrollbars_->begin();
        it != scrollbars_->end();
        ++it)
-    (*it)->ScrollbarParametersDidChange();
+    (*it)->ScrollbarParametersDidChange(on_resize);
 }
 
 void LayerImpl::SetNeedsPushProperties() {
   if (needs_push_properties_)
     return;
   if (!parent_should_know_need_push_properties() && parent_)
     parent_->AddDependentNeedsPushProperties();
   needs_push_properties_ = true;
 }
 
@@ skipping 154 matching lines @@
 }
 
 void LayerImpl::NotifyAnimationFinished(
     base::TimeTicks monotonic_time,
     Animation::TargetProperty target_property) {
   if (target_property == Animation::ScrollOffset)
     layer_tree_impl_->InputScrollAnimationFinished();
 }
 
 }  // namespace cc