Overlay scrollbars expand only when mouse is near thumb

cc/input/single_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/single_scrollbar_animation_controller_thinning.h"
 
 #include <algorithm>
 
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "cc/input/scrollbar_animation_controller.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/scrollbar_layer_impl_base.h"
 #include "cc/trees/layer_tree_impl.h"
 
 namespace cc {
 
+namespace {
+
+float DistanceToScrollbarTrack(const gfx::PointF& device_viewport_point,
+                               const ScrollbarLayerImplBase* scrollbar) {
+  if (!scrollbar)

[bokan, 2017/04/28 18:08:11]

Make the scrollbar param a ref and avoid calling the function at the callsite if
there's no scrollbar for the orientation.

+    return std::numeric_limits<float>::max();
+
+  gfx::Rect scrollbar_bounds(scrollbar->bounds());
+
+  gfx::RectF device_viewport_scrollbar_bounds = 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 ScrollbarLayerImplBase* scrollbar) {
+  if (!scrollbar)
+    return std::numeric_limits<float>::max();
+
+  gfx::Rect thumb_bounds(scrollbar->ComputeExpandedThumbQuadRect());
+
+  gfx::RectF device_viewport_scrollbar_thumb_bounds = MathUtil::MapClippedRect(
+      scrollbar->ScreenSpaceTransform(), gfx::RectF(thumb_bounds));
+
+  return device_viewport_scrollbar_thumb_bounds.ManhattanDistanceToPoint(
+             device_viewport_point) /
+         scrollbar->layer_tree_impl()->device_scale_factor();
+}
+
+}  // namespace
+
 std::unique_ptr<SingleScrollbarAnimationControllerThinning>
 SingleScrollbarAnimationControllerThinning::Create(
     ElementId scroll_element_id,
     ScrollbarOrientation orientation,
     ScrollbarAnimationControllerClient* client,
     base::TimeDelta thinning_duration) {
   return base::WrapUnique(new SingleScrollbarAnimationControllerThinning(
       scroll_element_id, orientation, client, thinning_duration));
 }
 
 SingleScrollbarAnimationControllerThinning::
     SingleScrollbarAnimationControllerThinning(
         ElementId scroll_element_id,
         ScrollbarOrientation orientation,
         ScrollbarAnimationControllerClient* client,
         base::TimeDelta thinning_duration)
     : client_(client),
       is_animating_(false),
       scroll_element_id_(scroll_element_id),
       orientation_(orientation),
       captured_(false),
-      mouse_is_over_scrollbar_(false),
-      mouse_is_near_scrollbar_(false),
+      mouse_is_over_scrollbar_thumb_(false),
+      mouse_is_near_scrollbar_thumb_(false),
+      mouse_is_near_scrollbar_track_(false),
       thickness_change_(NONE),
       thinning_duration_(thinning_duration) {
   ApplyThumbThicknessScale(kIdleThicknessScale);
 }
 
+ScrollbarLayerImplBase*
+SingleScrollbarAnimationControllerThinning::GetScrollbar() const {
+  for (ScrollbarLayerImplBase* scrollbar :
+       client_->ScrollbarsFor(scroll_element_id_)) {
+    if (!scrollbar->is_overlay_scrollbar())

[bokan, 2017/04/28 18:08:11]

This can be a DCHECK right? We should never have a thinning controller if the
scrollbar isn't overlay.

+      continue;
+
+    if (scrollbar->orientation() == orientation_)
+      return scrollbar;
+  }
+
+  return nullptr;
+}
+
 bool SingleScrollbarAnimationControllerThinning::Animate(base::TimeTicks now) {
   if (!is_animating_)
     return false;
 
   if (last_awaken_time_.is_null())
     last_awaken_time_ = now;
 
   float progress = AnimationProgressAtTime(now);
   RunAnimationFrame(progress);
 
@@ skipping 29 matching lines @@
   is_animating_ = true;
   last_awaken_time_ = base::TimeTicks();
   client_->SetNeedsAnimateForScrollbarAnimation();
 }
 
 void SingleScrollbarAnimationControllerThinning::StopAnimation() {
   is_animating_ = false;
 }
 
 void SingleScrollbarAnimationControllerThinning::DidMouseDown() {
-  if (!mouse_is_over_scrollbar_)
+  if (!mouse_is_over_scrollbar_thumb_)
     return;
 
   StopAnimation();
   captured_ = true;
   ApplyThumbThicknessScale(1.f);
 }
 
 void SingleScrollbarAnimationControllerThinning::DidMouseUp() {
   if (!captured_)
     return;
 
   captured_ = false;
   StopAnimation();
 
-  if (!mouse_is_near_scrollbar_) {
+  if (!mouse_is_near_scrollbar_thumb_) {
     thickness_change_ = DECREASE;
     StartAnimation();
   } else {
     thickness_change_ = NONE;
   }
 }
 
 void SingleScrollbarAnimationControllerThinning::DidMouseLeave() {
-  if (!mouse_is_over_scrollbar_ && !mouse_is_near_scrollbar_)
+  if (!mouse_is_over_scrollbar_thumb_ && !mouse_is_near_scrollbar_thumb_)
     return;
 
-  mouse_is_over_scrollbar_ = false;
-  mouse_is_near_scrollbar_ = false;
+  mouse_is_over_scrollbar_thumb_ = false;
+  mouse_is_near_scrollbar_thumb_ = false;
+  mouse_is_near_scrollbar_track_ = false;
 
   if (captured_)
     return;
 
   thickness_change_ = DECREASE;
   StartAnimation();
 }
 
-void SingleScrollbarAnimationControllerThinning::DidMouseMoveNear(
-    float distance) {
-  bool mouse_is_over_scrollbar = distance == 0.0f;
-  bool mouse_is_near_scrollbar =
-      distance < kDefaultMouseMoveDistanceToTriggerAnimation;
+void SingleScrollbarAnimationControllerThinning::DidMouseMove(
+    const gfx::PointF& device_viewport_point) {
+  ScrollbarLayerImplBase* scrollbar = GetScrollbar();
 
-  if (!captured_ && mouse_is_near_scrollbar != mouse_is_near_scrollbar_) {
-    thickness_change_ = mouse_is_near_scrollbar ? INCREASE : DECREASE;
+  float distance_to_scrollbar_track =
+      DistanceToScrollbarTrack(device_viewport_point, scrollbar);
+  float distance_to_scrollbar_thumb =
+      DistanceToScrollbarThumb(device_viewport_point, scrollbar);
+
+  mouse_is_near_scrollbar_track_ =
+      distance_to_scrollbar_track <
+      ScrollbarAnimationController::kMouseMoveDistanceToTriggerFadeIn;
+
+  bool mouse_is_over_scrollbar_thumb = distance_to_scrollbar_thumb == 0.0f;
+  bool mouse_is_near_scrollbar_thumb =
+      distance_to_scrollbar_thumb < kMouseMoveDistanceToTriggerExpand;
+
+  if (!captured_ &&
+      mouse_is_near_scrollbar_thumb != mouse_is_near_scrollbar_thumb_) {
+    thickness_change_ = mouse_is_near_scrollbar_thumb ? INCREASE : DECREASE;
     StartAnimation();
   }
-  mouse_is_near_scrollbar_ = mouse_is_near_scrollbar;
-  mouse_is_over_scrollbar_ = mouse_is_over_scrollbar;
+  mouse_is_near_scrollbar_thumb_ = mouse_is_near_scrollbar_thumb;
+  mouse_is_over_scrollbar_thumb_ = mouse_is_over_scrollbar_thumb;
 }
 
 float SingleScrollbarAnimationControllerThinning::ThumbThicknessScaleAt(
     float progress) {
   if (thickness_change_ == NONE)
-    return mouse_is_near_scrollbar_ ? 1.f : kIdleThicknessScale;
+    return mouse_is_near_scrollbar_thumb_ ? 1.f : kIdleThicknessScale;
   float factor = thickness_change_ == INCREASE ? progress : (1.f - progress);
   return ((1.f - kIdleThicknessScale) * factor) + kIdleThicknessScale;
 }
 
 float SingleScrollbarAnimationControllerThinning::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;
 }
 
 void SingleScrollbarAnimationControllerThinning::UpdateThumbThicknessScale() {
   StopAnimation();
-  ApplyThumbThicknessScale(mouse_is_near_scrollbar_ ? 1.f
-                                                    : kIdleThicknessScale);
+  ApplyThumbThicknessScale(
+      mouse_is_near_scrollbar_thumb_ ? 1.f : kIdleThicknessScale);
 }
 
 void SingleScrollbarAnimationControllerThinning::ApplyThumbThicknessScale(
     float thumb_thickness_scale) {
   for (auto* scrollbar : client_->ScrollbarsFor(scroll_element_id_)) {
     if (scrollbar->orientation() != orientation_)
       continue;
     if (!scrollbar->is_overlay_scrollbar())
       continue;
 
     float scale = AdjustScale(thumb_thickness_scale,
                               scrollbar->thumb_thickness_scale_factor(),
                               thickness_change_, kIdleThicknessScale, 1);
 
     scrollbar->SetThumbThicknessScaleFactor(scale);
   }
 }
 
 }  // namespace cc