Overlay scrollbars expand only when mouse is near thumb

cc/input/scrollbar_animation_controller_unittest.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.h"
 
 #include "cc/layers/solid_color_scrollbar_layer_impl.h"
 #include "cc/test/fake_impl_task_runner_provider.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/test_task_graph_runner.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::AtLeast;
 using testing::Mock;
 using testing::NiceMock;
 using testing::_;
 
 namespace cc {
 namespace {
 
 const float kIdleThicknessScale =
     SingleScrollbarAnimationControllerThinning::kIdleThicknessScale;
-const float kDefaultMouseMoveDistanceToTriggerAnimation =
-    SingleScrollbarAnimationControllerThinning::
-        kDefaultMouseMoveDistanceToTriggerAnimation;
 const float kMouseMoveDistanceToTriggerFadeIn =
     ScrollbarAnimationController::kMouseMoveDistanceToTriggerFadeIn;
+const float kMouseMoveDistanceToTriggerExpand =
+    SingleScrollbarAnimationControllerThinning::
+        kMouseMoveDistanceToTriggerExpand;
 const int kThumbThickness = 10;
 
 class MockScrollbarAnimationControllerClient
     : public ScrollbarAnimationControllerClient {
  public:
   explicit MockScrollbarAnimationControllerClient(LayerTreeHostImpl* host_impl)
       : host_impl_(host_impl) {}
   virtual ~MockScrollbarAnimationControllerClient() {}
 
   void PostDelayedScrollbarAnimationTask(const base::Closure& start_fade,
@@ skipping 39 matching lines @@
         LayerImpl::Create(host_impl_.active_tree(), 1);
     std::unique_ptr<LayerImpl> clip =
         LayerImpl::Create(host_impl_.active_tree(), 2);
     clip_layer_ = clip.get();
     scroll_layer->SetElementId(
         LayerIdToElementIdForTesting(scroll_layer->id()));
     scroll_layer->SetScrollClipLayer(clip_layer_->id());
     LayerImpl* scroll_layer_ptr = scroll_layer.get();
 
     const int kTrackStart = 0;
+    const int kTrackLength = 100;
     const bool kIsLeftSideVerticalScrollbar = false;
     const bool kIsOverlayScrollbar = true;
 
     std::unique_ptr<SolidColorScrollbarLayerImpl> h_scrollbar =
         SolidColorScrollbarLayerImpl::Create(
             host_impl_.active_tree(), 3, HORIZONTAL, kThumbThickness,
             kTrackStart, kIsLeftSideVerticalScrollbar, kIsOverlayScrollbar);
     std::unique_ptr<SolidColorScrollbarLayerImpl> v_scrollbar =
         SolidColorScrollbarLayerImpl::Create(
             host_impl_.active_tree(), 4, VERTICAL, kThumbThickness, kTrackStart,
             kIsLeftSideVerticalScrollbar, kIsOverlayScrollbar);
     v_scrollbar_layer_ = v_scrollbar.get();
     h_scrollbar_layer_ = h_scrollbar.get();
 
     scroll_layer->test_properties()->AddChild(std::move(v_scrollbar));
     scroll_layer->test_properties()->AddChild(std::move(h_scrollbar));
     clip_layer_->test_properties()->AddChild(std::move(scroll_layer));
     host_impl_.active_tree()->SetRootLayerForTesting(std::move(clip));
 
+    v_scrollbar_layer_->SetBounds(gfx::Size(kThumbThickness, kTrackLength));
+    v_scrollbar_layer_->SetPosition(gfx::PointF(90, 0));
     v_scrollbar_layer_->SetScrollElementId(scroll_layer_ptr->element_id());
+    v_scrollbar_layer_->test_properties()->opacity_can_animate = true;
+
+    h_scrollbar_layer_->SetBounds(gfx::Size(kTrackLength, kThumbThickness));
+    h_scrollbar_layer_->SetPosition(gfx::PointF(0, 90));
     h_scrollbar_layer_->SetScrollElementId(scroll_layer_ptr->element_id());
-    v_scrollbar_layer_->test_properties()->opacity_can_animate = true;
     h_scrollbar_layer_->test_properties()->opacity_can_animate = true;
+
     clip_layer_->SetBounds(gfx::Size(100, 100));
     scroll_layer_ptr->SetBounds(gfx::Size(200, 200));
     host_impl_.active_tree()->BuildLayerListAndPropertyTreesForTesting();
 
     scrollbar_controller_ = ScrollbarAnimationController::
         CreateScrollbarAnimationControllerAuraOverlay(
             scroll_layer_ptr->element_id(), &client_, kFadeDelay,
             kResizeFadeOutDelay, kFadeDuration, kThinningDuration);
+
+    v_scrollbar_layer_->SetCurrentPos(0);
+    h_scrollbar_layer_->SetCurrentPos(0);
+  }
+
+  gfx::PointF NearVerticalScrollbarBegin(float offset_x, float offset_y) {

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

Please add a short description comment above these methods describing what
they're used for and what they return.

+    gfx::PointF p(90, 0);
+    p.Offset(offset_x, offset_y);
+    return p;
+  }
+
+  gfx::PointF NearVerticalScrollbarEnd(float offset_x, float offset_y) {
+    gfx::PointF p(90, 90);
+    p.Offset(offset_x, offset_y);
+    return p;
+  }
+
+  gfx::PointF NearHorizontalScrollbarBegin(float offset_x, float offset_y) {
+    gfx::PointF p(0, 90);
+    p.Offset(offset_x, offset_y);
+    return p;
   }
 
   FakeImplTaskRunnerProvider task_runner_provider_;
   TestTaskGraphRunner task_graph_runner_;
   FakeLayerTreeHostImpl host_impl_;
   std::unique_ptr<ScrollbarAnimationController> scrollbar_controller_;
   LayerImpl* clip_layer_;
   SolidColorScrollbarLayerImpl* v_scrollbar_layer_;
   SolidColorScrollbarLayerImpl* h_scrollbar_layer_;
   NiceMock<MockScrollbarAnimationControllerClient> client_;
@@ skipping 121 matching lines @@
 
   // Scrollbar should fade out over kFadeDuration.
   scrollbar_controller_->Animate(time);
   time += kFadeDuration;
   scrollbar_controller_->Animate(time);
 
   ExpectScrollbarsOpacity(0);
   EXPECT_TRUE(scrollbar_controller_->ScrollbarsHidden());
 }
 
-// Scroll content. Move the mouse near the scrollbar and confirm it becomes
-// thick. Ensure it remains visible as long as the mouse is near the scrollbar.
+// Scroll content. Move the mouse near the scrollbar track but not near thumb
+// and confirm it keeps thick. Move the mouse near the scrollbar thumb and

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

I think you meant "confirm it stays thin" on this line, right?

+// confirm it becomes thick.
+TEST_F(ScrollbarAnimationControllerAuraOverlayTest,
+       MoveNearTrackThenNearThumb) {
+  base::TimeTicks time;
+  time += base::TimeDelta::FromSeconds(1);
+
+  scrollbar_controller_->DidScrollBegin();
+  scrollbar_controller_->DidScrollUpdate();
+  scrollbar_controller_->DidScrollEnd();
+
+  // An fade out animation should have been enqueued.
+  EXPECT_EQ(kFadeDelay, client_.delay());
+  EXPECT_FALSE(client_.start_fade().is_null());
+  EXPECT_FALSE(client_.start_fade().IsCancelled());
+
+  // Now move the mouse near the vertical scrollbar track. This should cancel
+  // the currently queued fading animation and start animating thickness.

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

We don't start animating thickness until you move near the thumb so move that
part of the comment below. You want to confirm it stays thin though (which you
do but add that to the comment).

+  scrollbar_controller_->DidMouseMove(NearVerticalScrollbarEnd(-1, 0));
+  ExpectScrollbarsOpacity(1);
+  EXPECT_FLOAT_EQ(kIdleThicknessScale,
+                  v_scrollbar_layer_->thumb_thickness_scale_factor());
+  EXPECT_FLOAT_EQ(kIdleThicknessScale,
+                  h_scrollbar_layer_->thumb_thickness_scale_factor());
+  EXPECT_TRUE(client_.start_fade().IsCancelled());
+
+  scrollbar_controller_->Animate(time);
+  time += kThinningDuration;
+  scrollbar_controller_->Animate(time);
+
+  EXPECT_FLOAT_EQ(kIdleThicknessScale,
+                  v_scrollbar_layer_->thumb_thickness_scale_factor());
+  EXPECT_FLOAT_EQ(kIdleThicknessScale,
+                  h_scrollbar_layer_->thumb_thickness_scale_factor());
+
+  scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(-1, 0));
+  scrollbar_controller_->Animate(time);
+  time += kThinningDuration;
+  scrollbar_controller_->Animate(time);
+
+  EXPECT_FLOAT_EQ(1, v_scrollbar_layer_->thumb_thickness_scale_factor());
+  EXPECT_FLOAT_EQ(kIdleThicknessScale,
+                  h_scrollbar_layer_->thumb_thickness_scale_factor());
+
+  scrollbar_controller_->DidMouseMove(NearVerticalScrollbarEnd(-1, 0));
+  EXPECT_FLOAT_EQ(1, v_scrollbar_layer_->thumb_thickness_scale_factor());
+  EXPECT_FLOAT_EQ(kIdleThicknessScale,
+                  h_scrollbar_layer_->thumb_thickness_scale_factor());
+  EXPECT_TRUE(client_.start_fade().IsCancelled());
+
+  scrollbar_controller_->Animate(time);
+  time += kThinningDuration;
+  scrollbar_controller_->Animate(time);
+
+  EXPECT_FLOAT_EQ(kIdleThicknessScale,
+                  v_scrollbar_layer_->thumb_thickness_scale_factor());
+  EXPECT_FLOAT_EQ(kIdleThicknessScale,
+                  h_scrollbar_layer_->thumb_thickness_scale_factor());
+}
+
+// Scroll content. Move the mouse near the scrollbar thumb and confirm it
+// becomes thick. Ensure it remains visible as long as the mouse is near the
+// scrollbar.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest, MoveNearAndDontFadeOut) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
   scrollbar_controller_->DidScrollEnd();
 
   // An fade out animation should have been enqueued.
   EXPECT_EQ(kFadeDelay, client_.delay());
   EXPECT_FALSE(client_.start_fade().is_null());
   EXPECT_FALSE(client_.start_fade().IsCancelled());
 
-  // Now move the mouse near the scrollbar. This should cancel the currently
-  // queued fading animation and start animating thickness.
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL, 1);
+  // Now move the mouse near the vertical scrollbar thumb. This should cancel
+  // the currently queued fading animation and start animating thickness.
+  scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(-1, 0));
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_TRUE(client_.start_fade().IsCancelled());
 
   // Vertical scrollbar should become thick.
   scrollbar_controller_->Animate(time);
   time += kThinningDuration;
@@ skipping 18 matching lines @@
 
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
   scrollbar_controller_->DidScrollEnd();
 
   // An fade out animation should have been enqueued.
   EXPECT_EQ(kFadeDelay, client_.delay());
   EXPECT_FALSE(client_.start_fade().is_null());
   EXPECT_FALSE(client_.start_fade().IsCancelled());
 
-  // Now move the mouse over the scrollbar. This should cancel the currently
-  // queued fading animation and start animating thickness.
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL, 0);
+  // Now move the mouse over the vertical scrollbar thumb. This should cancel
+  // the currently queued fading animation and start animating thickness.
+  scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(0, 0));
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_TRUE(client_.start_fade().IsCancelled());
 
   // Vertical scrollbar should become thick.
   scrollbar_controller_->Animate(time);
   time += kThinningDuration;
@@ skipping 18 matching lines @@
   time += base::TimeDelta::FromSeconds(1);
 
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
   scrollbar_controller_->DidScrollEnd();
 
   // An fade out animation should have been enqueued.
   EXPECT_EQ(kFadeDelay, client_.delay());
   EXPECT_FALSE(client_.start_fade().is_null());
 
-  // Now move the mouse over the scrollbar and capture it. It should become
-  // thick without need for an animation.
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL, 0);
+  // Now move the mouse over the vertical scrollbar thumb and capture it. It
+  // should become thick without need for an animation.
+  scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(0, 0));
   scrollbar_controller_->DidMouseDown();
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(1, v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   // The fade out animation should have been cleared or cancelled.
   EXPECT_TRUE(client_.start_fade().is_null() ||
               client_.start_fade().IsCancelled());
 }
 
 // Make sure a scrollbar captured then move mouse away doesn't try to fade out.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest,
        DontFadeWhileCapturedThenAway) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
   scrollbar_controller_->DidScrollEnd();
 
   // An fade out animation should have been enqueued.
   EXPECT_EQ(kFadeDelay, client_.delay());
   EXPECT_FALSE(client_.start_fade().is_null());
 
-  // Now move the mouse over the scrollbar and capture it. It should become
-  // thick without need for an animation.
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL, 0);
+  // Now move the mouse over the vertical scrollbar and capture it. It should
+  // become thick without need for an animation.
+  scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(0, 0));
   scrollbar_controller_->DidMouseDown();
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(1, v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   // The fade out animation should have been cleared or cancelled.
   EXPECT_TRUE(client_.start_fade().is_null() ||
               client_.start_fade().IsCancelled());
 
   // Then move mouse away, The fade out animation should have been cleared or
   // cancelled.
-  scrollbar_controller_->DidMouseMoveNear(
-      VERTICAL, kDefaultMouseMoveDistanceToTriggerAnimation);
+  scrollbar_controller_->DidMouseMove(
+      NearVerticalScrollbarBegin(-kMouseMoveDistanceToTriggerExpand, 0));
 
   EXPECT_TRUE(client_.start_fade().is_null() ||
               client_.start_fade().IsCancelled());
 }
 
 // Make sure a scrollbar captured after a thickening animation doesn't try to
 // fade out.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest, DontFadeWhileCaptured) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
   scrollbar_controller_->DidScrollEnd();
 
   // An fade out animation should have been enqueued.
   EXPECT_EQ(kFadeDelay, client_.delay());
   EXPECT_FALSE(client_.start_fade().is_null());
   EXPECT_FALSE(client_.start_fade().IsCancelled());
 
-  // Now move the mouse over the scrollbar and animate it until it's thick.
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL, 0);
+  // Now move the mouse over the vertical scrollbar thumb and animate it until
+  // it's thick.
+  scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(0, 0));
   scrollbar_controller_->Animate(time);
   time += kThinningDuration;
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(1, v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   // Since the mouse is over the scrollbar, it should either clear or cancel the
   // queued fade.
@@ skipping 15 matching lines @@
 
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
   scrollbar_controller_->DidScrollEnd();
 
   // An fade out animation should have been enqueued.
   EXPECT_EQ(kFadeDelay, client_.delay());
   EXPECT_FALSE(client_.start_fade().is_null());
   EXPECT_FALSE(client_.start_fade().IsCancelled());
 
-  // Now move the mouse over the scrollbar and capture it.
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL, 0);
+  // Now move the mouse over the vertical scrollbar thumb and capture it.
+  scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(0, 0));
   scrollbar_controller_->DidMouseDown();
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(1, v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   // Since the mouse is still near the scrollbar, the queued fade should be
   // either null or cancelled.
   EXPECT_TRUE(client_.start_fade().is_null() ||
               client_.start_fade().IsCancelled());
 
   // Now move the mouse away from the scrollbar and release it.
-  scrollbar_controller_->DidMouseMoveNear(
-      VERTICAL, kDefaultMouseMoveDistanceToTriggerAnimation);
+  scrollbar_controller_->DidMouseMove(
+      NearVerticalScrollbarBegin(-kMouseMoveDistanceToTriggerFadeIn, 0));
   scrollbar_controller_->DidMouseUp();
 
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(1, v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
   time += kThinningDuration;
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
@@ skipping 15 matching lines @@
 
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
   scrollbar_controller_->DidScrollEnd();
 
   // An fade out animation should have been enqueued.
   EXPECT_EQ(kFadeDelay, client_.delay());
   EXPECT_FALSE(client_.start_fade().is_null());
   EXPECT_FALSE(client_.start_fade().IsCancelled());
 
-  // Now move the mouse over the scrollbar and capture it.
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL, 0);
+  // Now move the mouse over the vertical scrollbar thumb and capture it.
+  scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(0, 0));
   scrollbar_controller_->DidMouseDown();
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(1, v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   // Since the mouse is over the scrollbar, the queued fade must be either
   // null or cancelled.
   EXPECT_TRUE(client_.start_fade().is_null() ||
               client_.start_fade().IsCancelled());
@@ skipping 25 matching lines @@
   client_.start_fade().Run();
 
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
 
   // Proceed half way through the fade out animation.
   time += kFadeDuration / 2;
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(.5f);
 
-  // Now move the mouse near the scrollbar. It should reset opacity to 1
-  // instantly and start animating to thick.
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL, 1);
+  // Now move the mouse near the vertical scrollbar thumb. It should reset
+  // opacity to 1 instantly and start animating to thick.
+  scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(0, 0));
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   scrollbar_controller_->Animate(time);
   time += kThinningDuration;
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
@@ skipping 16 matching lines @@
   EXPECT_FALSE(client_.start_fade().IsCancelled());
   client_.start_fade().Run();
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
 
   // Fade the scrollbar out completely.
   time += kFadeDuration;
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(0);
 
-  // Move mouse over the scrollbar. It shouldn't thicken the scrollbar since
-  // it's completely faded out.
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL, 0);
+  // Move mouse over the vertical scrollbar thumb. It shouldn't thicken the
+  // scrollbar since it's completely faded out.
+  scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(0, 0));
   scrollbar_controller_->Animate(time);
   time += kThinningDuration;
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(0);
   EXPECT_FLOAT_EQ(1, v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   client_.start_fade().Reset();
 
@@ skipping 14 matching lines @@
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_TRUE(client_.start_fade().is_null());
 }
 
 // Initiate a scroll when the pointer is already near the scrollbar. It should
 // appear thick and remain thick.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest, ScrollWithMouseNear) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL, 1);
+  scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(-1, 0));
   scrollbar_controller_->Animate(time);
   time += kThinningDuration;
 
   // Since the scrollbar isn't visible yet (because we haven't scrolled), we
   // shouldn't have applied the thickening.
   scrollbar_controller_->Animate(time);
   EXPECT_FLOAT_EQ(1, v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 
@@ skipping 153 matching lines @@
 // moved away.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest, MouseNearEach) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   // Scroll to make the scrollbars visible.
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
   scrollbar_controller_->DidScrollEnd();
 
-  // Near vertical scrollbar
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL, 1);
+  // Near vertical scrollbar.
+  scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(-1, 0));
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   // Should animate to thickened.
   time += kThinningDuration;
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(1, v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   // Subsequent moves within the nearness threshold should not change anything.
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL, 2);
+  scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(-2, 0));
   scrollbar_controller_->Animate(time);
   time += base::TimeDelta::FromSeconds(10);
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(1, v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   // Now move away from bar.
-  scrollbar_controller_->DidMouseMoveNear(
-      VERTICAL, kDefaultMouseMoveDistanceToTriggerAnimation);
+  scrollbar_controller_->DidMouseMove(
+      NearVerticalScrollbarBegin(-kMouseMoveDistanceToTriggerExpand, 0));
   scrollbar_controller_->Animate(time);
   time += kThinningDuration;
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   // Near horizontal scrollbar
-  scrollbar_controller_->DidMouseMoveNear(HORIZONTAL, 2);
+  scrollbar_controller_->DidMouseMove(NearHorizontalScrollbarBegin(0, -1));
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   // Should animate to thickened.
   time += kThinningDuration;
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(1, h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   // Subsequent moves within the nearness threshold should not change anything.
-  scrollbar_controller_->DidMouseMoveNear(HORIZONTAL, 1);
+  scrollbar_controller_->DidMouseMove(NearHorizontalScrollbarBegin(0, -2));
   scrollbar_controller_->Animate(time);
   time += base::TimeDelta::FromSeconds(10);
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(1, h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   // Now move away from bar.
-  scrollbar_controller_->DidMouseMoveNear(
-      HORIZONTAL, kDefaultMouseMoveDistanceToTriggerAnimation);
+  scrollbar_controller_->DidMouseMove(
+      NearHorizontalScrollbarBegin(0, -kMouseMoveDistanceToTriggerExpand));
   scrollbar_controller_->Animate(time);
   time += kThinningDuration;
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   // An fade out animation should have been enqueued.
   EXPECT_FALSE(client_.start_fade().is_null());
   EXPECT_EQ(kFadeDelay, client_.delay());
 }
 
 // Move mouse near both scrollbars at the same time.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest, MouseNearBoth) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   // Scroll to make the scrollbars visible.
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
   scrollbar_controller_->DidScrollEnd();
 
+  // Move scrollbar thumb to the end of track.
+  v_scrollbar_layer_->SetCurrentPos(100);
+  h_scrollbar_layer_->SetCurrentPos(100);
+
   // Near both Scrollbar
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL, 1);
-  scrollbar_controller_->DidMouseMoveNear(HORIZONTAL, 1);
+  scrollbar_controller_->DidMouseMove(NearVerticalScrollbarEnd(-1, -1));
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   // Should animate to thickened.
   time += kThinningDuration;
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(1, v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(1, h_scrollbar_layer_->thumb_thickness_scale_factor());
 }
 
 // Move mouse from one to the other scrollbar before animation is finished, then
 // away before animation finished.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest,
        MouseNearOtherBeforeAnimationFinished) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   // Scroll to make the scrollbars visible.
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
   scrollbar_controller_->DidScrollEnd();
 
   // Near vertical scrollbar.
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL, 1);
+  scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(-1, 0));
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   // Vertical scrollbar animate to half thickened.
   time += kThinningDuration / 2;
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(kIdleThicknessScale + (1.0f - kIdleThicknessScale) / 2,
                   v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   // Away vertical scrollbar and near horizontal scrollbar.
-  scrollbar_controller_->DidMouseMoveNear(
-      VERTICAL, kDefaultMouseMoveDistanceToTriggerAnimation);
-  scrollbar_controller_->DidMouseMoveNear(HORIZONTAL, 1);
+  scrollbar_controller_->DidMouseMove(gfx::PointF(0, 0));
+  scrollbar_controller_->DidMouseMove(NearHorizontalScrollbarBegin(0, -1));
   scrollbar_controller_->Animate(time);
 
   // Vertical scrollbar animate to thin. horizontal scrollbar animate to
   // thickened.
   time += kThinningDuration;
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(1, h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   // Away horizontal scrollbar.
-  scrollbar_controller_->DidMouseMoveNear(
-      HORIZONTAL, kDefaultMouseMoveDistanceToTriggerAnimation);
+  scrollbar_controller_->DidMouseMove(gfx::PointF(0, 0));
   scrollbar_controller_->Animate(time);
 
   // Horizontal scrollbar animate to thin.
   time += kThinningDuration;
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   h_scrollbar_layer_->thumb_thickness_scale_factor());
 
   // An fade out animation should have been enqueued.
   EXPECT_FALSE(client_.start_fade().is_null());
   EXPECT_EQ(kFadeDelay, client_.delay());
 }
 
 // Ensure we have a delay fadeout animation after mouse leave without a mouse
 // move.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest, MouseLeaveFadeOut) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   // Move mouse near scrollbar.
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL, 1);
+  scrollbar_controller_->DidMouseMove(NearVerticalScrollbarBegin(-1, 0));
 
   // Scroll to make the scrollbars visible.
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate();
   scrollbar_controller_->DidScrollEnd();
 
   // Should not have delay fadeout animation.
   EXPECT_TRUE(client_.start_fade().is_null() ||
               client_.start_fade().IsCancelled());
 
   // Mouse leave.
   scrollbar_controller_->DidMouseLeave();
 
   // An fade out animation should have been enqueued.
   EXPECT_FALSE(client_.start_fade().is_null());
   EXPECT_EQ(kFadeDelay, client_.delay());
 }
 
 // Scrollbars should schedule a delay fade in when mouse hover the show
 // scrollbar region of a hidden scrollbar.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest, BasicMouseHoverFadeIn) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   // Move mouse hover the fade in scrollbar region of scrollbar.
-  scrollbar_controller_->DidMouseMoveNear(
-      VERTICAL, kMouseMoveDistanceToTriggerFadeIn - 1);
+  scrollbar_controller_->DidMouseMove(
+      NearVerticalScrollbarBegin(-kMouseMoveDistanceToTriggerFadeIn + 1, 0));
 
   // An fade in animation should have been enqueued.
   EXPECT_FALSE(client_.start_fade().is_null());
   EXPECT_FALSE(client_.start_fade().IsCancelled());
   EXPECT_EQ(kFadeDelay, client_.delay());
 
   // Play the delay animation.
   client_.start_fade().Run();
   EXPECT_TRUE(client_.start_fade().IsCancelled());
 
@@ skipping 12 matching lines @@
 }
 
 // Scrollbars should not schedule a new delay fade in when the mouse hovers
 // inside a scrollbar already scheduled a delay fade in.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest,
        MouseHoverScrollbarAndMoveInside) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   // Move mouse hover the fade in scrollbar region of scrollbar.
-  scrollbar_controller_->DidMouseMoveNear(
-      VERTICAL, kMouseMoveDistanceToTriggerFadeIn - 1);
+  scrollbar_controller_->DidMouseMove(
+      NearVerticalScrollbarBegin(-kMouseMoveDistanceToTriggerFadeIn + 1, 0));
 
   // An fade in animation should have been enqueued.
   EXPECT_FALSE(client_.start_fade().is_null());
   EXPECT_FALSE(client_.start_fade().IsCancelled());
   EXPECT_EQ(kFadeDelay, client_.delay());
 
   base::Closure& fade = client_.start_fade();
   // Move mouse still hover the fade in scrollbar region of scrollbar should not
   // post a new fade in.
-  scrollbar_controller_->DidMouseMoveNear(
-      VERTICAL, kMouseMoveDistanceToTriggerFadeIn - 2);
+  scrollbar_controller_->DidMouseMove(
+      NearVerticalScrollbarBegin(-kMouseMoveDistanceToTriggerFadeIn + 2, 0));
 
   EXPECT_TRUE(fade.Equals(client_.start_fade()));
 }
 
 // Scrollbars should cancel delay fade in when mouse hover hidden scrollbar then
 // move far away.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest,
        MouseHoverThenOutShouldCancelFadeIn) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   // Move mouse hover the fade in scrollbar region of scrollbar.
-  scrollbar_controller_->DidMouseMoveNear(
-      VERTICAL, kMouseMoveDistanceToTriggerFadeIn - 1);
+  scrollbar_controller_->DidMouseMove(
+      NearVerticalScrollbarBegin(-kMouseMoveDistanceToTriggerFadeIn + 1, 0));
 
   // An fade in animation should have been enqueued.
   EXPECT_FALSE(client_.start_fade().is_null());
   EXPECT_FALSE(client_.start_fade().IsCancelled());
   EXPECT_EQ(kFadeDelay, client_.delay());
 
   // Move mouse far away，delay fade in should be canceled.
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL,
-                                          kMouseMoveDistanceToTriggerFadeIn);
+  scrollbar_controller_->DidMouseMove(
+      NearVerticalScrollbarBegin(-kMouseMoveDistanceToTriggerFadeIn, 0));
+
   EXPECT_TRUE(client_.start_fade().is_null() ||
               client_.start_fade().IsCancelled());
 }
 
 // Scrollbars should cancel delay fade in when mouse hover hidden scrollbar then
 // move out of window.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest,
        MouseHoverThenLeaveShouldCancelShowThenEnterShouldFadeIn) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   // Move mouse hover the fade in scrollbar region of scrollbar.
-  scrollbar_controller_->DidMouseMoveNear(
-      VERTICAL, kMouseMoveDistanceToTriggerFadeIn - 1);
+  scrollbar_controller_->DidMouseMove(
+      NearVerticalScrollbarBegin(-kMouseMoveDistanceToTriggerFadeIn + 1, 0));
 
   // An fade in animation should have been enqueued.
   EXPECT_FALSE(client_.start_fade().is_null());
   EXPECT_FALSE(client_.start_fade().IsCancelled());
   EXPECT_EQ(kFadeDelay, client_.delay());
 
   // Move mouse out of window，delay fade in should be canceled.
   scrollbar_controller_->DidMouseLeave();
   EXPECT_TRUE(client_.start_fade().is_null() ||
               client_.start_fade().IsCancelled());
 
   // Move mouse hover the fade in scrollbar region of scrollbar.
-  scrollbar_controller_->DidMouseMoveNear(
-      VERTICAL, kMouseMoveDistanceToTriggerFadeIn - 1);
+  scrollbar_controller_->DidMouseMove(
+      NearVerticalScrollbarBegin(-kMouseMoveDistanceToTriggerFadeIn + 1, 0));
 
   // An fade in animation should have been enqueued.
   EXPECT_FALSE(client_.start_fade().is_null());
   EXPECT_FALSE(client_.start_fade().IsCancelled());
   EXPECT_EQ(kFadeDelay, client_.delay());
 
   // Play the delay animation.
   client_.start_fade().Run();
   EXPECT_TRUE(client_.start_fade().IsCancelled());
 
@@ skipping 491 matching lines @@
   EXPECT_FLOAT_EQ(1, scrollbar_layer_->Opacity());
 
   time += base::TimeDelta::FromSeconds(1);
   scrollbar_controller_->DidScrollEnd();
   EXPECT_FALSE(did_request_animate_);
   EXPECT_FLOAT_EQ(1, scrollbar_layer_->Opacity());
 }
 
 }  // namespace
 }  // namespace cc