Remove resize fade delay plumbing.

cc/input/scrollbar_animation_controller.cc

 // Copyright 2014 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/input/scrollbar_animation_controller.h"
 
 #include <algorithm>
 
 #include "base/time/time.h"
 #include "cc/trees/layer_tree_impl.h"
 
 namespace cc {
 
 std::unique_ptr<ScrollbarAnimationController>
 ScrollbarAnimationController::CreateScrollbarAnimationControllerAndroid(
     ElementId scroll_element_id,
     ScrollbarAnimationControllerClient* client,
     base::TimeDelta fade_delay,
-    base::TimeDelta fade_out_resize_delay,
     base::TimeDelta fade_duration) {
-  return base::WrapUnique(
-      new ScrollbarAnimationController(scroll_element_id, client, fade_delay,
-                                       fade_out_resize_delay, fade_duration));
+  return base::WrapUnique(new ScrollbarAnimationController(
+      scroll_element_id, client, fade_delay, fade_duration));
 }
 
 std::unique_ptr<ScrollbarAnimationController>
 ScrollbarAnimationController::CreateScrollbarAnimationControllerAuraOverlay(
     ElementId scroll_element_id,
     ScrollbarAnimationControllerClient* client,
     base::TimeDelta fade_delay,
-    base::TimeDelta fade_out_resize_delay,
     base::TimeDelta fade_duration,
     base::TimeDelta thinning_duration) {
   return base::WrapUnique(new ScrollbarAnimationController(
-      scroll_element_id, client, fade_delay, fade_out_resize_delay,
-      fade_duration, thinning_duration));
+      scroll_element_id, client, fade_delay, fade_duration, thinning_duration));
 }
 
 ScrollbarAnimationController::ScrollbarAnimationController(
     ElementId scroll_element_id,
     ScrollbarAnimationControllerClient* client,
     base::TimeDelta fade_delay,
-    base::TimeDelta fade_out_resize_delay,
     base::TimeDelta fade_duration)
     : client_(client),
       fade_delay_(fade_delay),
-      fade_out_resize_delay_(fade_out_resize_delay),
       fade_duration_(fade_duration),
       need_trigger_scrollbar_show_(false),
       is_animating_(false),
       animation_change_(NONE),
       scroll_element_id_(scroll_element_id),
       currently_scrolling_(false),
       show_in_fast_scroll_(false),
       opacity_(0.0f),
       show_scrollbars_on_scroll_gesture_(false),
       need_thinning_animation_(false),
       weak_factory_(this) {
   ApplyOpacityToScrollbars(0.0f);
 }
 
 ScrollbarAnimationController::ScrollbarAnimationController(
     ElementId scroll_element_id,
     ScrollbarAnimationControllerClient* client,
     base::TimeDelta fade_delay,
-    base::TimeDelta fade_out_resize_delay,
     base::TimeDelta fade_duration,
     base::TimeDelta thinning_duration)
     : client_(client),
       fade_delay_(fade_delay),
-      fade_out_resize_delay_(fade_out_resize_delay),
       fade_duration_(fade_duration),
       need_trigger_scrollbar_show_(false),
       is_animating_(false),
       animation_change_(NONE),
       scroll_element_id_(scroll_element_id),
       currently_scrolling_(false),
       show_in_fast_scroll_(false),
       opacity_(0.0f),
       show_scrollbars_on_scroll_gesture_(true),
       need_thinning_animation_(true),
@@ skipping 31 matching lines @@
   client_->SetNeedsAnimateForScrollbarAnimation();
 }
 
 void ScrollbarAnimationController::StopAnimation() {
   delayed_scrollbar_animation_.Cancel();
   is_animating_ = false;
   animation_change_ = NONE;
 }
 
 void ScrollbarAnimationController::PostDelayedAnimation(
-    AnimationChange animation_change,
-    bool on_resize) {
+    AnimationChange animation_change) {
   animation_change_ = animation_change;
-
-  base::TimeDelta delay = on_resize ? fade_out_resize_delay_ : fade_delay_;
-
   delayed_scrollbar_animation_.Cancel();
   delayed_scrollbar_animation_.Reset(
       base::Bind(&ScrollbarAnimationController::StartAnimation,
                  weak_factory_.GetWeakPtr()));
   client_->PostDelayedScrollbarAnimationTask(
-      delayed_scrollbar_animation_.callback(), delay);
+      delayed_scrollbar_animation_.callback(), fade_delay_);
 }
 
 bool ScrollbarAnimationController::Animate(base::TimeTicks now) {
   bool animated = false;
 
   if (is_animating_) {
     DCHECK(animation_change_ != NONE);
     if (last_awaken_time_.is_null())
       last_awaken_time_ = now;
 
@@ skipping 44 matching lines @@
   show_in_fast_scroll_ = false;
 
   currently_scrolling_ = false;
 
   // We don't fade out scrollbar if they need thinning animation and mouse is
   // near.
   if (need_thinning_animation_ && MouseIsNearAnyScrollbar())
     return;
 
   if (has_scrolled)
-    PostDelayedAnimation(FADE_OUT, false);
+    PostDelayedAnimation(FADE_OUT);
 }
 
 void ScrollbarAnimationController::DidScrollUpdate() {
   if (need_thinning_animation_ && Captured())
     return;
 
   StopAnimation();
 
   Show();
 
   // As an optimization, we avoid spamming fade delay tasks during active fast
   // scrolls.  But if we're not within one, we need to post every scroll update.
   if (!currently_scrolling_) {
     // We don't fade out scrollbar if they need thinning animation and mouse is
     // near.
     if (!need_thinning_animation_ || !MouseIsNearAnyScrollbar())
-      PostDelayedAnimation(FADE_OUT, false);
+      PostDelayedAnimation(FADE_OUT);
   } else {
     show_in_fast_scroll_ = true;
   }
 
   if (need_thinning_animation_) {
     vertical_controller_->UpdateThumbThicknessScale();
     horizontal_controller_->UpdateThumbThicknessScale();
   }
 }
 
 void ScrollbarAnimationController::WillUpdateScroll() {
   if (show_scrollbars_on_scroll_gesture_)
     DidScrollUpdate();
 }
 
 void ScrollbarAnimationController::DidRequestShowFromMainThread() {
   DidScrollUpdate();
 }
 
-void ScrollbarAnimationController::DidResize() {
-  StopAnimation();
-  Show();
-
-  // As an optimization, we avoid spamming fade delay tasks during active fast
-  // scrolls.
-  if (!currently_scrolling_) {
-    PostDelayedAnimation(FADE_OUT, true);
-  } else {
-    show_in_fast_scroll_ = true;
-  }
-}
-
 void ScrollbarAnimationController::DidMouseDown() {
   if (!need_thinning_animation_ || ScrollbarsHidden())
     return;
 
   vertical_controller_->DidMouseDown();
   horizontal_controller_->DidMouseDown();
 }
 
 void ScrollbarAnimationController::DidMouseUp() {
   if (!need_thinning_animation_ || !Captured())
     return;
 
   vertical_controller_->DidMouseUp();
   horizontal_controller_->DidMouseUp();
 
   if (!MouseIsNearAnyScrollbar())
-    PostDelayedAnimation(FADE_OUT, false);
+    PostDelayedAnimation(FADE_OUT);
 }
 
 void ScrollbarAnimationController::DidMouseLeave() {
   if (!need_thinning_animation_)
     return;
 
   vertical_controller_->DidMouseLeave();
   horizontal_controller_->DidMouseLeave();
 
   delayed_scrollbar_animation_.Cancel();
   need_trigger_scrollbar_show_ = false;
 
   if (ScrollbarsHidden() || Captured())
     return;
 
-  PostDelayedAnimation(FADE_OUT, false);
+  PostDelayedAnimation(FADE_OUT);
 }
 
 void ScrollbarAnimationController::DidMouseMoveNear(
     ScrollbarOrientation orientation,
     float distance) {
   if (!need_thinning_animation_)
     return;
 
   bool need_trigger_scrollbar_show_before = need_trigger_scrollbar_show_;
 
   GetScrollbarAnimationController(orientation).DidMouseMoveNear(distance);
 
   need_trigger_scrollbar_show_ =
       CalcNeedTriggerScrollbarShow(orientation, distance);
 
   if (Captured())
     return;
 
   if (ScrollbarsHidden()) {
     if (need_trigger_scrollbar_show_before != need_trigger_scrollbar_show_) {
       if (need_trigger_scrollbar_show_) {
-        PostDelayedAnimation(FADE_IN, false);
+        PostDelayedAnimation(FADE_IN);
       } else {
         delayed_scrollbar_animation_.Cancel();
       }
     }
   } else {
     if (MouseIsNearAnyScrollbar()) {
       Show();
       StopAnimation();
     } else if (!is_animating_) {
-      PostDelayedAnimation(FADE_OUT, false);
+      PostDelayedAnimation(FADE_OUT);
     }
   }
 }
 
 bool ScrollbarAnimationController::CalcNeedTriggerScrollbarShow(
     ScrollbarOrientation orientation,
     float distance) const {
   DCHECK(need_thinning_animation_);
 
   if (vertical_controller_->mouse_is_over_scrollbar() ||
@@ skipping 57 matching lines @@
   if (opacity_ != opacity)
     client_->SetNeedsRedrawForScrollbarAnimation();
 
   opacity_ = opacity;
 
   if (previouslyVisible != currentlyVisible)
     client_->DidChangeScrollbarVisibility();
 }
 
 }  // namespace cc