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"
@@ skipping 22 matching lines @@
 }
 
 ScrollbarAnimationController::ScrollbarAnimationController(
     ElementId scroll_element_id,
     ScrollbarAnimationControllerClient* client,
     base::TimeDelta fade_delay,
     base::TimeDelta fade_duration)
     : client_(client),
       fade_delay_(fade_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_duration,
     base::TimeDelta thinning_duration)
     : client_(client),
       fade_delay_(fade_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);
+
   ApplyOpacityToScrollbars(0.0f);
 }
 
 ScrollbarAnimationController::~ScrollbarAnimationController() {}
 
 ScrollbarSet ScrollbarAnimationController::Scrollbars() const {
   return client_->ScrollbarsFor(scroll_element_id_);
 }
 
 SingleScrollbarAnimationControllerThinning&
@@ skipping 150 matching lines @@
 }
 
 void ScrollbarAnimationController::DidMouseLeave() {
   if (!need_thinning_animation_)
     return;
 
   vertical_controller_->DidMouseLeave();
   horizontal_controller_->DidMouseLeave();
 
   delayed_scrollbar_animation_.Cancel();
-  need_trigger_scrollbar_show_ = false;
+  need_trigger_scrollbar_fade_in_ = false;
 
   if (ScrollbarsHidden() || Captured())
     return;
 
   PostDelayedAnimation(FADE_OUT);
 }
 
-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);
+  vertical_controller_->DidMouseMove(device_viewport_point);
+  horizontal_controller_->DidMouseMove(device_viewport_point);
 
-  need_trigger_scrollbar_show_ =
-      CalcNeedTriggerScrollbarShow(orientation, distance);
+  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);
       } else {
         delayed_scrollbar_animation_.Cancel();
       }
     }
   } else {
     if (MouseIsNearAnyScrollbar()) {
       Show();
       StopAnimation();
     } else if (!is_animating_) {
       PostDelayedAnimation(FADE_OUT);
     }
   }
 }
 
-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 GetScrollbarAnimationController(orientation)
+      .mouse_is_near_scrollbar_track();
 }
 
 bool ScrollbarAnimationController::MouseIsNearAnyScrollbar() const {
   DCHECK(need_thinning_animation_);
-  return vertical_controller_->mouse_is_near_scrollbar() ||
-         horizontal_controller_->mouse_is_near_scrollbar();
+  return vertical_controller_->mouse_is_near_scrollbar_track() ||
+         horizontal_controller_->mouse_is_near_scrollbar_track();
 }
 
 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;
+    DCHECK(scrollbar->is_overlay_scrollbar());
     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