Prevent overlay scrollbars expand or hover together

cc/input/scrollbar_animation_controller_thinning.cc

Index: cc/input/scrollbar_animation_controller_thinning.cc
diff --git a/cc/input/scrollbar_animation_controller_thinning.cc b/cc/input/scrollbar_animation_controller_thinning.cc
index 587c60f79a8b6355b1a23423c0e693ba87ac678e..a69be78d8dc4529875b3b0349208f100030ae1c5 100644
--- a/cc/input/scrollbar_animation_controller_thinning.cc
+++ b/cc/input/scrollbar_animation_controller_thinning.cc
@@ -10,11 +10,6 @@
 #include "cc/layers/scrollbar_layer_impl_base.h"
 #include "cc/trees/layer_tree_impl.h"
 
-namespace {
-const float kIdleThicknessScale = 0.4f;
-const float kDefaultMouseMoveDistanceToTriggerAnimation = 25.f;
-}
-
 namespace cc {
 
 std::unique_ptr<ScrollbarAnimationControllerThinning>
@@ -42,170 +37,124 @@ ScrollbarAnimationControllerThinning::ScrollbarAnimationControllerThinning(
                                    delay_before_starting,
                                    resize_delay_before_starting),
       opacity_(0.0f),
-      captured_(false),
-      mouse_is_over_scrollbar_(false),
-      mouse_is_near_scrollbar_(false),
-      thickness_change_(NONE),
-      mouse_move_distance_to_trigger_animation_(
-          kDefaultMouseMoveDistanceToTriggerAnimation),
-      fade_duration_(fade_duration),
-      thinning_duration_(thinning_duration),
-      current_animating_property_(OPACITY) {
-  ApplyOpacity(0.f);
-  ApplyThumbThicknessScale(kIdleThicknessScale);
+      fade_duration_(fade_duration) {
+  vertical_controller_ = SingleScrollbarAnimationControllerThinning::Create(
+      scroll_layer_id, ScrollbarOrientation::VERTICAL, client,
+      thinning_duration);
+  horizontal_controller_ = SingleScrollbarAnimationControllerThinning::Create(
+      scroll_layer_id, ScrollbarOrientation::HORIZONTAL, client,
+      thinning_duration);
+  ApplyOpacity(0.0f);
 }
 
 ScrollbarAnimationControllerThinning::~ScrollbarAnimationControllerThinning() {}
 
-void ScrollbarAnimationControllerThinning::RunAnimationFrame(float progress) {
-  if (captured_)
-    return;
-
-  if (current_animating_property_ == OPACITY)
-    ApplyOpacity(1.f - progress);
+SingleScrollbarAnimationControllerThinning&
+ScrollbarAnimationControllerThinning::GetScrollbarAnimationController(
+    ScrollbarOrientation orientation) const {
+  if (orientation == ScrollbarOrientation::VERTICAL)
+    return *(vertical_controller_.get());
   else
-    ApplyThumbThicknessScale(ThumbThicknessScaleAt(progress));
-
-  client_->SetNeedsRedrawForScrollbarAnimation();
-  if (progress == 1.f) {
-    StopAnimation();
-    if (current_animating_property_ == THICKNESS) {
-      thickness_change_ = NONE;
-      SetCurrentAnimatingProperty(OPACITY);
-      if (!mouse_is_near_scrollbar_)
-        PostDelayedAnimationTask(false);
-    }
-  }
+    return *(horizontal_controller_.get());
 }
 
-const base::TimeDelta& ScrollbarAnimationControllerThinning::Duration() {
-  if (current_animating_property_ == OPACITY)
-    return fade_duration_;
-  else
-    return thinning_duration_;
+bool ScrollbarAnimationControllerThinning::mouse_is_over_scrollbar(
+    ScrollbarOrientation orientation) const {
+  return GetScrollbarAnimationController(orientation).mouse_is_over_scrollbar();
 }
 
-void ScrollbarAnimationControllerThinning::DidMouseDown() {
-  if (!mouse_is_over_scrollbar_ || opacity_ == 0.0f)
-    return;
+bool ScrollbarAnimationControllerThinning::mouse_is_near_scrollbar(
+    ScrollbarOrientation orientation) const {
+  return GetScrollbarAnimationController(orientation).mouse_is_near_scrollbar();
+}
 
-  StopAnimation();
-  captured_ = true;
-  ApplyOpacity(1.f);
-  ApplyThumbThicknessScale(1.f);
+bool ScrollbarAnimationControllerThinning::mouse_is_near_any_scrollbar() const {
+  return vertical_controller_->mouse_is_near_scrollbar() ||
+         horizontal_controller_->mouse_is_near_scrollbar();
 }
 
-void ScrollbarAnimationControllerThinning::DidMouseUp() {
-  if (!captured_ || opacity_ == 0.0f)
-    return;
+bool ScrollbarAnimationControllerThinning::Captured() const {
+  return vertical_controller_->captured() || horizontal_controller_->captured();
+}
 
-  captured_ = false;
-  StopAnimation();
+bool ScrollbarAnimationControllerThinning::ScrollbarsHidden() const {
+  return opacity_ == 0.0f;
+}
 
-  if (!mouse_is_near_scrollbar_) {
-    SetCurrentAnimatingProperty(THICKNESS);
-    thickness_change_ = DECREASE;
-    StartAnimation();
-  } else {
-    SetCurrentAnimatingProperty(OPACITY);
-  }
+void ScrollbarAnimationControllerThinning::set_mouse_move_distance_for_test(
+    float distance) {
+  vertical_controller_->set_mouse_move_distance_for_test(distance);
+  horizontal_controller_->set_mouse_move_distance_for_test(distance);
 }
 
-void ScrollbarAnimationControllerThinning::DidMouseLeave() {
-  if (!mouse_is_over_scrollbar_ && !mouse_is_near_scrollbar_)
-    return;
+bool ScrollbarAnimationControllerThinning::Animate(base::TimeTicks now) {
+  bool animated = ScrollbarAnimationController::Animate(now);
+  animated |= vertical_controller_->Animate(now);
+  animated |= horizontal_controller_->Animate(now);
 
-  mouse_is_over_scrollbar_ = false;
-  mouse_is_near_scrollbar_ = false;
+  return animated;
+}
 
-  if (captured_ || opacity_ == 0.0f)
-    return;
+void ScrollbarAnimationControllerThinning::RunAnimationFrame(float progress) {
+  ApplyOpacity(1.f - progress);
+  if (progress == 1.f)
+    StopAnimation();
+}
 
-  thickness_change_ = DECREASE;
-  SetCurrentAnimatingProperty(THICKNESS);
-  StartAnimation();
+const base::TimeDelta& ScrollbarAnimationControllerThinning::Duration() {
+  return fade_duration_;
 }
 
-void ScrollbarAnimationControllerThinning::DidScrollUpdate(bool on_resize) {
-  if (captured_)
+void ScrollbarAnimationControllerThinning::DidMouseDown() {
+  if (ScrollbarsHidden())
     return;
-
-  ScrollbarAnimationController::DidScrollUpdate(on_resize);
-  ApplyOpacity(1.f);
-  ApplyThumbThicknessScale(mouse_is_near_scrollbar_ ? 1.f
-                                                    : kIdleThicknessScale);
-  SetCurrentAnimatingProperty(OPACITY);
-
-  // Don't fade out the scrollbar when mouse is near.
-  if (mouse_is_near_scrollbar_)
-    StopAnimation();
+  vertical_controller_->DidMouseDown();
+  horizontal_controller_->DidMouseDown();
 }
 
-void ScrollbarAnimationControllerThinning::DidScrollEnd() {
-  ScrollbarAnimationController::DidScrollEnd();
+void ScrollbarAnimationControllerThinning::DidMouseUp() {
+  vertical_controller_->DidMouseUp();
+  horizontal_controller_->DidMouseUp();
+}
 
-  // Don't fade out the scrollbar when mouse is near.
-  if (mouse_is_near_scrollbar_)
-    StopAnimation();
+void ScrollbarAnimationControllerThinning::DidMouseLeave() {
+  vertical_controller_->DidMouseLeave();
+  horizontal_controller_->DidMouseLeave();
 }
 
-void ScrollbarAnimationControllerThinning::DidMouseMoveNear(float distance) {
-  bool mouse_is_over_scrollbar = distance == 0.0f;
-  bool mouse_is_near_scrollbar =
-      distance < mouse_move_distance_to_trigger_animation_;
+void ScrollbarAnimationControllerThinning::DidMouseMoveNear(
+    ScrollbarOrientation orientation,
+    float distance) {
+  GetScrollbarAnimationController(orientation).DidMouseMoveNear(distance);
 
-  if (captured_ || opacity_ == 0.0f) {
-    mouse_is_near_scrollbar_ = mouse_is_near_scrollbar;
-    mouse_is_over_scrollbar_ = mouse_is_over_scrollbar;
-    return;
+  if (mouse_is_near_any_scrollbar() && !ScrollbarsHidden()) {
+    ApplyOpacity(1);
+    StopAnimation();
+  } else if (!animating_fade() && !currently_scrolling()) {

[bokan, 2016/12/21 23:06:09]

I don't think you need !currently_scrolling, it's used to distinguish a
continuous scroll like a touch scroll from wheel like discrete scrolls. If we're
touch scrolling (so that currently_scrolling == true) we can't be moving the
mouse. Instead, I would check that the scrollbars aren't hidden (actually just
return early if ScrollbarsHidden() above) in this branch as well since we don't
want to be spamming animation tasks when the scrollbars are already hidden.

+    PostDelayedAnimationTask(false);
   }
+}
 
-  if (mouse_is_over_scrollbar == mouse_is_over_scrollbar_ &&
-      mouse_is_near_scrollbar == mouse_is_near_scrollbar_)
+void ScrollbarAnimationControllerThinning::DidScrollUpdate(bool on_resize) {
+  if (Captured())
     return;
 
-  if (mouse_is_over_scrollbar_ != mouse_is_over_scrollbar)
-    mouse_is_over_scrollbar_ = mouse_is_over_scrollbar;
+  ScrollbarAnimationController::DidScrollUpdate(on_resize);
 
-  if (mouse_is_near_scrollbar_ != mouse_is_near_scrollbar) {
-    mouse_is_near_scrollbar_ = mouse_is_near_scrollbar;
-    thickness_change_ = mouse_is_near_scrollbar_ ? INCREASE : DECREASE;
-  }
+  ApplyOpacity(1);
+  vertical_controller_->UpdateThumbThicknessScale();
+  horizontal_controller_->UpdateThumbThicknessScale();
 
-  SetCurrentAnimatingProperty(THICKNESS);
-  StartAnimation();
-}
-
-bool ScrollbarAnimationControllerThinning::ScrollbarsHidden() const {
-  return opacity_ == 0.0f;
+  if (mouse_is_near_any_scrollbar())
+    StopAnimation();
 }
 
-float ScrollbarAnimationControllerThinning::ThumbThicknessScaleAt(
-    float progress) {
-  if (thickness_change_ == NONE)
-    return mouse_is_near_scrollbar_ ? 1.f : kIdleThicknessScale;
-  float factor = thickness_change_ == INCREASE ? progress : (1.f - progress);
-  return ((1.f - kIdleThicknessScale) * factor) + kIdleThicknessScale;
-}
+void ScrollbarAnimationControllerThinning::DidScrollEnd() {
+  ScrollbarAnimationController::DidScrollEnd();
 
-float ScrollbarAnimationControllerThinning::AdjustScale(
-    float new_value,
-    float current_value,
-    AnimationChange animation_change,
-    float min_value,
-    float max_value) {
-  float result;
-  if (animation_change == INCREASE && current_value > new_value)
-    result = current_value;
-  else if (animation_change == DECREASE && current_value < new_value)
-    result = current_value;
-  else
-    result = new_value;
-  if (result > max_value)
-    return max_value;
-  if (result < min_value)
-    return min_value;
-  return result;
+  // Don't fade out the scrollbar when mouse is near.
+  if (mouse_is_near_any_scrollbar())
+    StopAnimation();
 }
 
 void ScrollbarAnimationControllerThinning::ApplyOpacity(float opacity) {
@@ -238,27 +187,4 @@ void ScrollbarAnimationControllerThinning::ApplyOpacity(float opacity) {
     client_->DidChangeScrollbarVisibility();
 }
 
-void ScrollbarAnimationControllerThinning::ApplyThumbThicknessScale(
-    float thumb_thickness_scale) {
-  for (ScrollbarLayerImplBase* scrollbar : Scrollbars()) {
-    if (!scrollbar->is_overlay_scrollbar())
-      continue;
-
-    scrollbar->SetThumbThicknessScaleFactor(AdjustScale(
-        thumb_thickness_scale, scrollbar->thumb_thickness_scale_factor(),
-        thickness_change_, kIdleThicknessScale, 1));
-  }
-}
-
-void ScrollbarAnimationControllerThinning::SetCurrentAnimatingProperty(
-    AnimatingProperty property) {
-  if (current_animating_property_ == property)
-    return;
-
-  StopAnimation();
-  current_animating_property_ = property;
-  if (current_animating_property_ == THICKNESS)
-    ApplyOpacity(1.f);
-}
-
 }  // namespace cc