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 cc {
 
+namespace {
+
+float DistanceToScrollbarTrack(const gfx::PointF& device_viewport_point,
+                               const ScrollbarLayerImplBase* scrollbar) {
+  if (!scrollbar)
+    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();
+}
+
+const ScrollbarOrientation orientations[] = {HORIZONTAL, VERTICAL};

[bokan, 2017/04/28 14:15:17]

This is only used for one loop. Move this into the function where it's used.

+
+}  // namespace
+
 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));
@@ skipping 15 matching lines @@
 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),
+      need_trigger_scrollbar_fade_in_(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),
+      need_trigger_scrollbar_fade_in_(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),
       weak_factory_(this) {
-  vertical_controller_ = SingleScrollbarAnimationControllerThinning::Create(
-      scroll_element_id, ScrollbarOrientation::VERTICAL, client,
-      thinning_duration);
-  horizontal_controller_ = SingleScrollbarAnimationControllerThinning::Create(
-      scroll_element_id, ScrollbarOrientation::HORIZONTAL, client,
-      thinning_duration);
+  scrollbar_controllers_[ScrollbarOrientation::HORIZONTAL] =
+      SingleScrollbarAnimationControllerThinning::Create(
+          scroll_element_id, ScrollbarOrientation::HORIZONTAL, client,
+          thinning_duration);
+  scrollbar_controllers_[ScrollbarOrientation::VERTICAL] =
+      SingleScrollbarAnimationControllerThinning::Create(
+          scroll_element_id, ScrollbarOrientation::VERTICAL, client,
+          thinning_duration);
+
+  mouse_is_near_scrollbar_[ScrollbarOrientation::HORIZONTAL] = false;
+  mouse_is_near_scrollbar_[ScrollbarOrientation::VERTICAL] = false;
+
   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;
+  }
+
+  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());
+  return *scrollbar_controllers_[orientation].get();
 }
 
 void ScrollbarAnimationController::StartAnimation() {
   DCHECK(animation_change_ != NONE);
   delayed_scrollbar_animation_.Cancel();
   is_animating_ = true;
   last_awaken_time_ = base::TimeTicks();
   client_->SetNeedsAnimateForScrollbarAnimation();
 }
 
@@ skipping 28 matching lines @@
 
     float progress = AnimationProgressAtTime(now);
     RunAnimationFrame(progress);
 
     if (is_animating_)
       client_->SetNeedsAnimateForScrollbarAnimation();
     animated = true;
   }
 
   if (need_thinning_animation_) {
-    animated |= vertical_controller_->Animate(now);
-    animated |= horizontal_controller_->Animate(now);
+    for (auto& controller : scrollbar_controllers_)
+      animated |= controller->Animate(now);
   }
 
   return animated;
 }
 
 float ScrollbarAnimationController::AnimationProgressAtTime(
     base::TimeTicks now) {
   base::TimeDelta delta = now - last_awaken_time_;
   float progress = delta.InSecondsF() / fade_duration_.InSecondsF();
   return std::max(std::min(progress, 1.f), 0.f);
@@ skipping 46 matching lines @@
   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);
   } else {
     show_in_fast_scroll_ = true;
   }
 
   if (need_thinning_animation_) {
-    vertical_controller_->UpdateThumbThicknessScale();
-    horizontal_controller_->UpdateThumbThicknessScale();
+    for (auto& controller : scrollbar_controllers_)
+      controller->UpdateThumbThicknessScale();
   }
 }
 
 void ScrollbarAnimationController::WillUpdateScroll() {
   if (show_scrollbars_on_scroll_gesture_)
     DidScrollUpdate();
 }
 
 void ScrollbarAnimationController::DidRequestShowFromMainThread() {
   // TODO(skobes): Call DidScrollUpdate here (suppressed for crbug.com/706927).
 }
 
 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();
+  for (auto& controller : scrollbar_controllers_)
+    controller->DidMouseDown();
 }
 
 void ScrollbarAnimationController::DidMouseUp() {
   if (!need_thinning_animation_ || !Captured())
     return;
 
-  vertical_controller_->DidMouseUp();
-  horizontal_controller_->DidMouseUp();
+  for (auto& controller : scrollbar_controllers_)
+    controller->DidMouseUp();
 
   if (!MouseIsNearAnyScrollbar())
     PostDelayedAnimation(FADE_OUT, false);
 }
 
 void ScrollbarAnimationController::DidMouseLeave() {
   if (!need_thinning_animation_)
     return;
 
-  vertical_controller_->DidMouseLeave();
-  horizontal_controller_->DidMouseLeave();
+  for (auto& controller : scrollbar_controllers_)
+    controller->DidMouseLeave();
+
+  for (bool& mouse_is_near_scrollbar : mouse_is_near_scrollbar_)
+    mouse_is_near_scrollbar = false;
 
   delayed_scrollbar_animation_.Cancel();
-  need_trigger_scrollbar_show_ = false;
+  need_trigger_scrollbar_fade_in_ = false;
 
   if (ScrollbarsHidden() || Captured())
     return;
 
   PostDelayedAnimation(FADE_OUT, false);
 }
 
-void ScrollbarAnimationController::DidMouseMoveNear(
-    ScrollbarOrientation orientation,
-    float distance) {
+void ScrollbarAnimationController::DidMouseMove(
+    const gfx::PointF& device_viewport_point) {
   if (!need_thinning_animation_)
     return;
 
-  bool need_trigger_scrollbar_show_before = need_trigger_scrollbar_show_;
+  bool need_trigger_scrollbar_fade_in_before = need_trigger_scrollbar_fade_in_;
 
-  GetScrollbarAnimationController(orientation).DidMouseMoveNear(distance);
+  for (ScrollbarOrientation orientation : orientations) {
+    ScrollbarLayerImplBase* scrollbar = GetScrollbar(orientation);
+    float distance_to_scrollbar_track =
+        DistanceToScrollbarTrack(device_viewport_point, scrollbar);
+    float distance_to_scrollbar_thumb =
+        DistanceToScrollbarThumb(device_viewport_point, scrollbar);
 
-  need_trigger_scrollbar_show_ =
-      CalcNeedTriggerScrollbarShow(orientation, distance);
+    GetScrollbarAnimationController(orientation)
+        .DidMouseMove(distance_to_scrollbar_thumb);
+
+    mouse_is_near_scrollbar_[orientation] =
+        distance_to_scrollbar_track < kMouseMoveDistanceToTriggerFadeIn;
+  }
+
+  need_trigger_scrollbar_fade_in_ = MouseIsNearAnyScrollbar();
 
   if (Captured())
     return;
 
   if (ScrollbarsHidden()) {
-    if (need_trigger_scrollbar_show_before != need_trigger_scrollbar_show_) {
-      if (need_trigger_scrollbar_show_) {
+    if (need_trigger_scrollbar_fade_in_before !=
+        need_trigger_scrollbar_fade_in_) {
+      if (need_trigger_scrollbar_fade_in_) {
         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 {
+bool ScrollbarAnimationController::MouseIsOverScrollbarThumb(
+    ScrollbarOrientation orientation) const {
   DCHECK(need_thinning_animation_);
-
-  if (vertical_controller_->mouse_is_over_scrollbar() ||
-      horizontal_controller_->mouse_is_over_scrollbar())
-    return true;
-
-  for (ScrollbarLayerImplBase* scrollbar : Scrollbars()) {
-    if (scrollbar->orientation() != orientation)
-      continue;
-
-    if (distance < kMouseMoveDistanceToTriggerFadeIn)
-      return true;
-  }
-
-  return false;
+  return GetScrollbarAnimationController(orientation)
+      .mouse_is_over_scrollbar_thumb();
 }
 
-bool ScrollbarAnimationController::MouseIsOverScrollbar(
+bool ScrollbarAnimationController::MouseIsNearScrollbarThumb(
     ScrollbarOrientation orientation) const {
   DCHECK(need_thinning_animation_);
-  return GetScrollbarAnimationController(orientation).mouse_is_over_scrollbar();
+  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();
+  return mouse_is_near_scrollbar_[orientation];
 }
 
 bool ScrollbarAnimationController::MouseIsNearAnyScrollbar() const {
   DCHECK(need_thinning_animation_);
-  return vertical_controller_->mouse_is_near_scrollbar() ||
-         horizontal_controller_->mouse_is_near_scrollbar();
+  return MouseIsNearScrollbar(VERTICAL) || MouseIsNearScrollbar(HORIZONTAL);
 }
 
 bool ScrollbarAnimationController::ScrollbarsHidden() const {
   return opacity_ == 0.0f;
 }
 
 bool ScrollbarAnimationController::Captured() const {
   DCHECK(need_thinning_animation_);
-  return vertical_controller_->captured() || horizontal_controller_->captured();
+  return GetScrollbarAnimationController(VERTICAL).captured() ||
+         GetScrollbarAnimationController(HORIZONTAL).captured();
 }
 
 void ScrollbarAnimationController::Show() {
   delayed_scrollbar_animation_.Cancel();
   ApplyOpacityToScrollbars(1.0f);
 }
 
 void ScrollbarAnimationController::ApplyOpacityToScrollbars(float opacity) {
   for (ScrollbarLayerImplBase* scrollbar : Scrollbars()) {
     if (!scrollbar->is_overlay_scrollbar())
       continue;
     float effective_opacity = scrollbar->CanScrollOrientation() ? opacity : 0;
     scrollbar->SetOverlayScrollbarLayerOpacityAnimated(effective_opacity);
   }
 
   bool previouslyVisible = opacity_ > 0.0f;
   bool currentlyVisible = opacity > 0.0f;
 
   if (opacity_ != opacity)
     client_->SetNeedsRedrawForScrollbarAnimation();
 
   opacity_ = opacity;
 
   if (previouslyVisible != currentlyVisible)
     client_->DidChangeScrollbarVisibility();
 }
 
 }  // namespace cc