Prevent overlay scrollbars expand or hover together

cc/input/scrollbar_animation_controller_thinning.cc

 // Copyright 2013 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_thinning.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "cc/layers/layer_impl.h"
 #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>
 ScrollbarAnimationControllerThinning::Create(
     int scroll_layer_id,
     ScrollbarAnimationControllerClient* client,
     base::TimeDelta delay_before_starting,
     base::TimeDelta resize_delay_before_starting,
     base::TimeDelta fade_duration,
     base::TimeDelta thinning_duration) {
   return base::WrapUnique(new ScrollbarAnimationControllerThinning(
       scroll_layer_id, client, delay_before_starting,
       resize_delay_before_starting, fade_duration, thinning_duration));
 }
 
 ScrollbarAnimationControllerThinning::ScrollbarAnimationControllerThinning(
     int scroll_layer_id,
     ScrollbarAnimationControllerClient* client,
     base::TimeDelta delay_before_starting,
     base::TimeDelta resize_delay_before_starting,
     base::TimeDelta fade_duration,
     base::TimeDelta thinning_duration)
     : ScrollbarAnimationController(scroll_layer_id,
                                    client,
                                    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);
+      opacity_(1.0f),

[bokan, 2016/12/19 16:11:47]

Why did we change starting opacity to 1? IIRC, starting at 0 was to ensure
proper initialization of the hidden state.

[chaopeng, 2016/12/20 20:05:55]

Because scrollbars show when page load is done, then fade out.

[bokan, 2016/12/21 15:56:02]

Right, but this worked before. Blink is responsible to causing the scrollbars to
show on load.

+      fade_duration_(fade_duration) {
+  vertical_controller_ = SingleScrollbarAnimationControllerThinning::Create(
+      scroll_layer_id, ScrollbarOrientation::VERTICAL, client,
+      delayed_scrollbar_fade(), thinning_duration);
+  horizontal_controller_ = SingleScrollbarAnimationControllerThinning::Create(
+      scroll_layer_id, ScrollbarOrientation::HORIZONTAL, client,
+      delayed_scrollbar_fade(), thinning_duration);
 }
 
 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;
-
-  StopAnimation();
-  captured_ = true;
-  ApplyOpacity(1.f);
-  ApplyThumbThicknessScale(1.f);
+bool ScrollbarAnimationControllerThinning::mouse_is_near_scrollbar(
+    ScrollbarOrientation orientation) const {
+  return GetScrollbarAnimationController(orientation).mouse_is_near_scrollbar();
 }
 
-void ScrollbarAnimationControllerThinning::DidMouseUp() {
-  if (!captured_ || opacity_ == 0.0f)
-    return;
-
-  captured_ = false;
-  StopAnimation();
-
-  if (!mouse_is_near_scrollbar_) {
-    SetCurrentAnimatingProperty(THICKNESS);
-    thickness_change_ = DECREASE;
-    StartAnimation();
-  } else {
-    SetCurrentAnimatingProperty(OPACITY);
-  }
+bool ScrollbarAnimationControllerThinning::mouse_is_near_any_scrollbar() const {
+  return vertical_controller_->mouse_is_near_scrollbar() ||
+         horizontal_controller_->mouse_is_near_scrollbar();
 }
 
-void ScrollbarAnimationControllerThinning::DidMouseLeave() {
-  if (!mouse_is_over_scrollbar_ && !mouse_is_near_scrollbar_)
-    return;
-
-  mouse_is_over_scrollbar_ = false;
-  mouse_is_near_scrollbar_ = false;
-
-  if (captured_ || opacity_ == 0.0f)
-    return;
-
-  thickness_change_ = DECREASE;
-  SetCurrentAnimatingProperty(THICKNESS);
-  StartAnimation();
-}
-
-void ScrollbarAnimationControllerThinning::DidScrollUpdate(bool on_resize) {
-  if (captured_)
-    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();
-}
-
-void ScrollbarAnimationControllerThinning::DidScrollEnd() {
-  ScrollbarAnimationController::DidScrollEnd();
-
-  // Don't fade out the scrollbar when mouse is near.
-  if (mouse_is_near_scrollbar_)
-    StopAnimation();
-}
-
-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_;
-
-  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_over_scrollbar == mouse_is_over_scrollbar_ &&
-      mouse_is_near_scrollbar == mouse_is_near_scrollbar_)
-    return;
-
-  if (mouse_is_over_scrollbar_ != mouse_is_over_scrollbar)
-    mouse_is_over_scrollbar_ = mouse_is_over_scrollbar;
-
-  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;
-  }
-
-  SetCurrentAnimatingProperty(THICKNESS);
-  StartAnimation();
+bool ScrollbarAnimationControllerThinning::captured() const {
+  return vertical_controller_->captured() || horizontal_controller_->captured();
 }
 
 bool ScrollbarAnimationControllerThinning::ScrollbarsHidden() const {
   return opacity_ == 0.0f;
 }
 
-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::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);
 }
 
-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;
+bool ScrollbarAnimationControllerThinning::Animate(base::TimeTicks now) {
+  if (animating())
+    return ScrollbarAnimationController::Animate(now);

[bokan, 2016/12/19 16:11:47]

As I noted in a comment in the SingleScrollbar class, rather than returning
here, let them both run simultaneously. That should simplify things.

+
+  bool need_animate = vertical_controller_->Animate(now);
+  need_animate = horizontal_controller_->Animate(now) || need_animate;

[bokan, 2016/12/19 16:11:47]

need_animate |=

+
+  if (need_animate) {
+    client_->SetNeedsAnimateForScrollbarAnimation();
+  } else if (vertical_controller_->ShouldFadeOut() &&
+             horizontal_controller_->ShouldFadeOut()) {
+    PostDelayedAnimationTask(false);
+  }
+
+  return need_animate;
+}
+
+void ScrollbarAnimationControllerThinning::RunAnimationFrame(float progress) {
+  ApplyOpacity(1.f - progress);
+  if (progress == 1.f)
+    StopAnimation();
+}
+
+const base::TimeDelta& ScrollbarAnimationControllerThinning::Duration() {
+  return fade_duration_;
+}
+
+void ScrollbarAnimationControllerThinning::DidMouseDown() {
+  vertical_controller_->DidMouseDown();
+  horizontal_controller_->DidMouseDown();
+}
+
+void ScrollbarAnimationControllerThinning::DidMouseUp() {
+  vertical_controller_->DidMouseUp();
+  horizontal_controller_->DidMouseUp();
+}
+
+void ScrollbarAnimationControllerThinning::DidMouseLeave() {
+  vertical_controller_->DidMouseLeave();
+  horizontal_controller_->DidMouseLeave();
+}
+
+void ScrollbarAnimationControllerThinning::DidMouseMoveNear(
+    ScrollbarOrientation orientation,
+    float distance) {
+  GetScrollbarAnimationController(orientation).DidMouseMoveNear(distance);
+  EnsureScrollbarFadeIn();
+}
+
+void ScrollbarAnimationControllerThinning::DidScrollUpdate(bool on_resize) {
+  if (captured())
+    return;
+
+  FadeIn();
+  vertical_controller_->UpdateThumbThicknessScale();
+  horizontal_controller_->UpdateThumbThicknessScale();
+
+  // Don't fade out the scrollbar when mouse is near.
+  if (!mouse_is_near_any_scrollbar())
+    PostDelayedAnimationTask(on_resize);
+}
+
+void ScrollbarAnimationControllerThinning::DidScrollEnd() {
+  ScrollbarAnimationController::DidScrollEnd();
+  EnsureScrollbarFadeIn();
+}
+
+void ScrollbarAnimationControllerThinning::EnsureScrollbarFadeIn() {

[bokan, 2016/12/19 16:11:47]

Call this FadeInIfNeeded

+  // Don't fade out the scrollbar when mouse is near.

[bokan, 2016/12/19 16:11:47]

I don't get why we need this method, the fade in/out of scrollbars shouldn't
depend on the mouse position. Why do we want to fade the scrollbars in when the
scroll ends and why only when the mouse is near? Also, the comment is about fade
out.

[chaopeng, 2016/12/20 20:05:54]

I changed it to `if (mouse_is_near_any_scrollbar() && !ScrollbarsHidden())`, we
need this to make scrollbars fade in and stop fade out animation when we move
mouse near scrollbars in middle of fade out animation.

[bokan, 2016/12/21 15:56:02]

Ah, ok. In that case, I would just inline this insie DidMouseMove since that's
the only place it's used. I'd also negate the if and wrap ApplyOpacity and
StopAnimation in it.

+  if (mouse_is_near_any_scrollbar())
+    FadeIn();
+}
+
+void ScrollbarAnimationControllerThinning::FadeIn() {
+  ApplyOpacity(1);
+  StopAnimation();
 }
 
 void ScrollbarAnimationControllerThinning::ApplyOpacity(float opacity) {
   for (ScrollbarLayerImplBase* scrollbar : Scrollbars()) {
     if (!scrollbar->is_overlay_scrollbar())
       continue;
     float effective_opacity = scrollbar->CanScrollOrientation() ? opacity : 0;
     PropertyTrees* property_trees =
         scrollbar->layer_tree_impl()->property_trees();
     // If this method is called during LayerImpl::PushPropertiesTo, we may not
     // yet have valid effect_id_to_index_map entries as property trees are
     // pushed after layers during activation. We can skip updating opacity in
     // that case as we are only registering a scrollbar and because opacity will
     // be overwritten anyway when property trees are pushed.
     if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::EFFECT,
                                          scrollbar->id())) {
       property_trees->effect_tree.OnOpacityAnimated(
           effective_opacity,
           property_trees->effect_id_to_index_map[scrollbar->id()],
           scrollbar->layer_tree_impl());
     }
   }
 
   bool previouslyVisible = opacity_ > 0.0f;
   bool currentlyVisible = opacity > 0.0f;
 
   opacity_ = opacity;
+  vertical_controller_->SetHidden(!currentlyVisible);
+  horizontal_controller_->SetHidden(!currentlyVisible);
 
   if (previouslyVisible != currentlyVisible)
     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