Overlay scrollbars expand only when mouse is near thumb

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 {
+
+float DistanceToScrollbar(const gfx::PointF& device_viewport_point,

[bokan, 2017/04/25 19:36:21]

This should be called "DistanceToScrollbarTrack"

+                          const cc::ScrollbarLayerImplBase* scrollbar) {
+  if (!scrollbar)
+    return std::numeric_limits<float>::max();
+
+  gfx::Rect scrollbar_bounds(scrollbar->bounds());
+
+  gfx::RectF device_viewport_scrollbar_bounds = cc::MathUtil::MapClippedRect(
+      scrollbar->ScreenSpaceTransform(), gfx::RectF(scrollbar_bounds));
+
+  return device_viewport_scrollbar_bounds.ManhattanDistanceToPoint(
+             device_viewport_point) /
+         scrollbar->layer_tree_impl()->device_scale_factor();
+}
+
+float DistanceToScrollbarThumb(const gfx::PointF& device_viewport_point,
+                               const cc::ScrollbarLayerImplBase* scrollbar) {
+  if (!scrollbar)
+    return std::numeric_limits<float>::max();
+
+  gfx::Rect thumb_bounds(scrollbar->ComputeExpandedThumbQuadRect());
+
+  gfx::RectF device_viewport_scrollbar_bounds = cc::MathUtil::MapClippedRect(
+      scrollbar->ScreenSpaceTransform(), gfx::RectF(thumb_bounds));
+
+  return device_viewport_scrollbar_bounds.ManhattanDistanceToPoint(
+             device_viewport_point) /
+         scrollbar->layer_tree_impl()->device_scale_factor();
+}
+
+}  // namespace
+
 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(
@@ skipping 66 matching lines @@
       thinning_duration);
   ApplyOpacityToScrollbars(0.0f);
 }
 
 ScrollbarAnimationController::~ScrollbarAnimationController() {}
 
 ScrollbarSet ScrollbarAnimationController::Scrollbars() const {
   return client_->ScrollbarsFor(scroll_element_id_);
 }
 
+ScrollbarLayerImplBase* ScrollbarAnimationController::GetScrollbar(
+    ScrollbarOrientation orientation) const {
+  for (ScrollbarLayerImplBase* scrollbar : Scrollbars()) {
+    if (!scrollbar->is_overlay_scrollbar())
+      continue;
+
+    if (scrollbar->orientation() == orientation)
+      return scrollbar;
+  }
+
+  NOTREACHED();
+  return nullptr;
+}
+
 SingleScrollbarAnimationControllerThinning&
 ScrollbarAnimationController::GetScrollbarAnimationController(
     ScrollbarOrientation orientation) const {
   DCHECK(need_thinning_animation_);
   if (orientation == ScrollbarOrientation::VERTICAL)
     return *(vertical_controller_.get());
   else
     return *(horizontal_controller_.get());
 }
 
@@ skipping 166 matching lines @@
 
   delayed_scrollbar_animation_.Cancel();
   need_trigger_scrollbar_show_ = false;
 
   if (ScrollbarsHidden() || Captured())
     return;
 
   PostDelayedAnimation(FADE_OUT, false);
 }
 
 void ScrollbarAnimationController::DidMouseMoveNear(

[bokan, 2017/04/25 19:36:21]

This no longer cares about distance - lets just call it DidMoveMouse

     ScrollbarOrientation orientation,
-    float distance) {
+    const gfx::PointF& device_viewport_point) {
   if (!need_thinning_animation_)
     return;
 
   bool need_trigger_scrollbar_show_before = need_trigger_scrollbar_show_;
 
-  GetScrollbarAnimationController(orientation).DidMouseMoveNear(distance);
+  ScrollbarLayerImplBase* scrollbar = GetScrollbar(orientation);
+
+  float distance_to_scrollbar =
+      DistanceToScrollbar(device_viewport_point, scrollbar);
+  float distance_to_thumb =
+      DistanceToScrollbarThumb(device_viewport_point, scrollbar);
+
+  GetScrollbarAnimationController(orientation)
+      .DidMouseMoveNear(distance_to_scrollbar, distance_to_thumb);
 
   need_trigger_scrollbar_show_ =
-      CalcNeedTriggerScrollbarShow(orientation, distance);
+      CalcNeedTriggerScrollbarShow(orientation, distance_to_scrollbar);
 
   if (Captured())
     return;
 
   if (ScrollbarsHidden()) {
     if (need_trigger_scrollbar_show_before != need_trigger_scrollbar_show_) {
       if (need_trigger_scrollbar_show_) {
         PostDelayedAnimation(FADE_IN, false);
       } else {
         delayed_scrollbar_animation_.Cancel();
       }
     }
   } else {
     if (MouseIsNearAnyScrollbar()) {
       Show();
       StopAnimation();
     } else if (!is_animating_) {
       PostDelayedAnimation(FADE_OUT, false);
     }
   }
 }
 
 bool ScrollbarAnimationController::CalcNeedTriggerScrollbarShow(
     ScrollbarOrientation orientation,
     float distance) const {
   DCHECK(need_thinning_animation_);
 
-  if (vertical_controller_->mouse_is_over_scrollbar() ||
-      horizontal_controller_->mouse_is_over_scrollbar())
+  if (vertical_controller_->mouse_is_over_scrollbar_thumb() ||

[bokan, 2017/04/25 19:36:21]

I think the show should still happen for "over the whole track". But I think
this method's accumulated some obsolete code. The scrollbars should show when
the mouse is near, not over, which is covered below so I think this is redundant
and can be removed, right?

+      horizontal_controller_->mouse_is_over_scrollbar_thumb())
     return true;
 
   for (ScrollbarLayerImplBase* scrollbar : Scrollbars()) {
     if (scrollbar->orientation() != orientation)
       continue;
 
     if (distance < kMouseMoveDistanceToTriggerFadeIn)
       return true;
   }
 
   return false;
 }
 
-bool ScrollbarAnimationController::MouseIsOverScrollbar(
+bool ScrollbarAnimationController::MouseIsOverScrollbarThumb(
     ScrollbarOrientation orientation) const {
   DCHECK(need_thinning_animation_);
-  return GetScrollbarAnimationController(orientation).mouse_is_over_scrollbar();
+  return GetScrollbarAnimationController(orientation)
+      .mouse_is_over_scrollbar_thumb();
+}
+
+bool ScrollbarAnimationController::MouseIsNearScrollbarThumb(
+    ScrollbarOrientation orientation) const {
+  DCHECK(need_thinning_animation_);
+  return GetScrollbarAnimationController(orientation)
+      .mouse_is_near_scrollbar_thumb();
 }
 
 bool ScrollbarAnimationController::MouseIsNearScrollbar(
     ScrollbarOrientation orientation) const {
   DCHECK(need_thinning_animation_);
   return GetScrollbarAnimationController(orientation).mouse_is_near_scrollbar();
 }
 
 bool ScrollbarAnimationController::MouseIsNearAnyScrollbar() const {
   DCHECK(need_thinning_animation_);
@@ skipping 29 matching lines @@
   if (opacity_ != opacity)
     client_->SetNeedsRedrawForScrollbarAnimation();
 
   opacity_ = opacity;
 
   if (previouslyVisible != currentlyVisible)
     client_->DidChangeScrollbarVisibility();
 }
 
 }  // namespace cc