Aura Overlay Scrollbars appear when mouse hovers over scroller edge

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 kMouseMoveDistanceToTriggerShow =
+    ScrollbarAnimationController::kMouseMoveDistanceToTriggerShow;
+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,
                                          base::TimeDelta delay) override {
@@ skipping 21 matching lines @@
   ScrollbarAnimationControllerAuraOverlayTest()
       : host_impl_(&task_runner_provider_, &task_graph_runner_),
         client_(&host_impl_) {}
 
   void ExpectScrollbarsOpacity(float opacity) {
     EXPECT_FLOAT_EQ(opacity, v_scrollbar_layer_->Opacity());
     EXPECT_FLOAT_EQ(opacity, h_scrollbar_layer_->Opacity());
   }
 
  protected:
-  const base::TimeDelta kDelayBeforeStarting = base::TimeDelta::FromSeconds(2);
-  const base::TimeDelta kResizeDelayBeforeStarting =
-      base::TimeDelta::FromSeconds(5);
-  const base::TimeDelta kFadeDuration = base::TimeDelta::FromSeconds(3);
+  const base::TimeDelta kShowDelay = base::TimeDelta::FromSeconds(4);
+  const base::TimeDelta kFadeOutDelay = base::TimeDelta::FromSeconds(2);
+  const base::TimeDelta kResizeFadeOutDelay = base::TimeDelta::FromSeconds(5);
+  const base::TimeDelta kFadeOutDuration = base::TimeDelta::FromSeconds(3);
   const base::TimeDelta kThinningDuration = base::TimeDelta::FromSeconds(2);
 
   void SetUp() override {
     std::unique_ptr<LayerImpl> scroll_layer =
         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->SetScrollClipLayer(clip_layer_->id());
     LayerImpl* scroll_layer_ptr = scroll_layer.get();
 
-    const int kThumbThickness = 10;
     const int kTrackStart = 0;
     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(
@@ skipping 10 matching lines @@
     v_scrollbar_layer_->SetScrollLayerId(scroll_layer_ptr->id());
     h_scrollbar_layer_->SetScrollLayerId(scroll_layer_ptr->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->id(), &client_, kDelayBeforeStarting,
-            kResizeDelayBeforeStarting, kFadeDuration, kThinningDuration);
+            scroll_layer_ptr->id(), &client_, kShowDelay, kFadeOutDelay,
+            kResizeFadeOutDelay, kFadeOutDuration, kThinningDuration);
   }
 
   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 78 matching lines @@
   EXPECT_TRUE(scrollbar_controller_->ScrollbarsHidden());
 
   scrollbar_controller_->DidScrollUpdate(false);
   ExpectScrollbarsOpacity(1);
   EXPECT_FALSE(scrollbar_controller_->ScrollbarsHidden());
 
   scrollbar_controller_->DidScrollEnd();
   ExpectScrollbarsOpacity(1);
   EXPECT_FALSE(scrollbar_controller_->ScrollbarsHidden());
 
-  // An animation should have been enqueued.
-  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  // An fade out animation should have been enqueued.
+  EXPECT_EQ(kFadeOutDelay, client_.delay());
   EXPECT_FALSE(client_.start_fade().is_null());
   client_.start_fade().Run();
 
-  // Scrollbar should fade out over kFadeDuration.
+  // Scrollbar should fade out over kFadeOutDuration.
   scrollbar_controller_->Animate(time);
-  time += kFadeDuration;
+  time += kFadeOutDuration;
   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.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest, MoveNearAndDontFadeOut) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate(false);
   scrollbar_controller_->DidScrollEnd();
 
-  // An animation should have been enqueued.
-  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  // An fade out animation should have been enqueued.
+  EXPECT_EQ(kFadeOutDelay, 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);
   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;
   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());
 
   // Mouse is still near the Scrollbar. Once the thickness animation is
-  // complete, the queued delayed fade animation should be either cancelled or
-  // null.
+  // complete, the queued delayed fade out animation should be either cancelled
+  // or null.
   EXPECT_TRUE(client_.start_fade().is_null() ||
               client_.start_fade().IsCancelled());
 }
 
 // Scroll content. Move the mouse over the scrollbar and confirm it becomes
 // thick. Ensure it remains visible as long as the mouse is over the scrollbar.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest, MoveOverAndDontFadeOut) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate(false);
   scrollbar_controller_->DidScrollEnd();
 
-  // An animation should have been enqueued.
-  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  // An fade out animation should have been enqueued.
+  EXPECT_EQ(kFadeOutDelay, 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);
   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;
   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());
 
   // Mouse is still over the Scrollbar. Once the thickness animation is
-  // complete, the queued delayed fade animation should be either cancelled or
-  // null.
+  // complete, the queued delayed fade out animation should be either cancelled
+  // or null.
   EXPECT_TRUE(client_.start_fade().is_null() ||
               client_.start_fade().IsCancelled());
 }
 
 // Make sure a scrollbar captured before the thickening animation doesn't try
 // to fade out.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest,
        DontFadeWhileCapturedBeforeThick) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate(false);
   scrollbar_controller_->DidScrollEnd();
 
-  // An animation should have been enqueued.
-  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  // An fade out animation should have been enqueued.
+  EXPECT_EQ(kFadeOutDelay, 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);
   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 animation should have been cleared or cancelled.
+  // 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(false);
   scrollbar_controller_->DidScrollEnd();
 
-  // An animation should have been enqueued.
-  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  // An fade out animation should have been enqueued.
+  EXPECT_EQ(kFadeOutDelay, 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);
   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 animation should have been cleared or cancelled.
+  // 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 animation should have been cleared or
+  // Then move mouse away, The fade out animation should have been cleared or
   // cancelled.
   scrollbar_controller_->DidMouseMoveNear(
       VERTICAL, kDefaultMouseMoveDistanceToTriggerAnimation);
 
   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(false);
   scrollbar_controller_->DidScrollEnd();
 
-  // An animation should have been enqueued.
-  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  // An fade out animation should have been enqueued.
+  EXPECT_EQ(kFadeOutDelay, 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);
   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.
   EXPECT_TRUE(client_.start_fade().is_null() ||
               client_.start_fade().IsCancelled());
 
-  // Make sure the queued fade animation is still null or cancelled after
+  // Make sure the queued fade out animation is still null or cancelled after
   // capturing the scrollbar.
   scrollbar_controller_->DidMouseDown();
   EXPECT_TRUE(client_.start_fade().is_null() ||
               client_.start_fade().IsCancelled());
 }
 
 // Make sure releasing a captured scrollbar when the mouse isn't near it, causes
 // the scrollbar to fade out.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest, FadeAfterReleasedFar) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate(false);
   scrollbar_controller_->DidScrollEnd();
 
-  // An animation should have been enqueued.
-  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  // An fade out animation should have been enqueued.
+  EXPECT_EQ(kFadeOutDelay, 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);
   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());
@@ skipping 29 matching lines @@
 // Make sure releasing a captured scrollbar when the mouse is near/over it,
 // doesn't cause the scrollbar to fade out.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest, DontFadeAfterReleasedNear) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate(false);
   scrollbar_controller_->DidScrollEnd();
 
-  // An animation should have been enqueued.
-  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  // An fade out animation should have been enqueued.
+  EXPECT_EQ(kFadeOutDelay, 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);
   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());
@@ skipping 17 matching lines @@
 // the opacity and thicken.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest,
        MoveNearScrollbarWhileFading) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate(false);
   scrollbar_controller_->DidScrollEnd();
 
-  // A fade animation should have been enqueued. Start it.
-  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  // A fade out animation should have been enqueued. Start it.
+  EXPECT_EQ(kFadeOutDelay, client_.delay());
   EXPECT_FALSE(client_.start_fade().is_null());
   client_.start_fade().Run();
 
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
 
   // Proceed half way through the fade out animation.
-  time += kFadeDuration / 2;
+  time += kFadeOutDuration / 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);
   ExpectScrollbarsOpacity(1);
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   v_scrollbar_layer_->thumb_thickness_scale_factor());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
@@ skipping 10 matching lines @@
 
 // Make sure we can't capture scrollbar that's completely faded out.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest, TestCantCaptureWhenFaded) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate(false);
   scrollbar_controller_->DidScrollEnd();
 
-  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  EXPECT_EQ(kFadeOutDelay, client_.delay());
   EXPECT_FALSE(client_.start_fade().is_null());
   EXPECT_FALSE(client_.start_fade().IsCancelled());
   client_.start_fade().Run();
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
 
   // Fade the scrollbar out completely.
-  time += kFadeDuration;
+  time += kFadeOutDuration;
   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);
   scrollbar_controller_->Animate(time);
   time += kThinningDuration;
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(0);
@@ skipping 50 matching lines @@
   EXPECT_TRUE(client_.start_fade().is_null() ||
               client_.start_fade().IsCancelled());
 
   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());
 
   // Scrollbar should still be thick and visible.
-  time += kFadeDuration;
+  time += kFadeOutDuration;
   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());
 }
 
-// Tests that main thread scroll updates immediatley queue a fade animation
+// Tests that main thread scroll updates immediatley queue a fade out animation
 // without requiring a ScrollEnd.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest,
        MainThreadScrollQueuesFade) {
   ASSERT_TRUE(client_.start_fade().is_null());
 
   // A ScrollUpdate without a ScrollBegin indicates a main thread scroll update
-  // so we should schedule a fade animation without waiting for a ScrollEnd
+  // so we should schedule a fade out animation without waiting for a ScrollEnd
   // (which will never come).
   scrollbar_controller_->DidScrollUpdate(false);
   EXPECT_FALSE(client_.start_fade().is_null());
-  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  EXPECT_EQ(kFadeOutDelay, client_.delay());
 
   client_.start_fade().Reset();
 
-  // If we got a ScrollBegin, we shouldn't schedule the fade animation until we
-  // get a corresponding ScrollEnd.
+  // If we got a ScrollBegin, we shouldn't schedule the fade out animation until
+  // we get a corresponding ScrollEnd.
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate(false);
   EXPECT_TRUE(client_.start_fade().is_null());
   scrollbar_controller_->DidScrollEnd();
   EXPECT_FALSE(client_.start_fade().is_null());
-  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  EXPECT_EQ(kFadeOutDelay, client_.delay());
 }
 
 // Make sure that if the scroll update is as a result of a resize, we use the
 // resize delay time instead of the default one.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest, ResizeFadeDuration) {
   ASSERT_TRUE(client_.delay().is_zero());
 
   scrollbar_controller_->DidScrollUpdate(true);
   EXPECT_FALSE(client_.start_fade().is_null());
-  EXPECT_EQ(kResizeDelayBeforeStarting, client_.delay());
+  EXPECT_EQ(kResizeFadeOutDelay, client_.delay());
 
   client_.delay() = base::TimeDelta();
 
   // We should use the gesture delay rather than the resize delay if we're in a
   // gesture scroll, even if the resize param is set.
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate(true);
   scrollbar_controller_->DidScrollEnd();
 
   EXPECT_FALSE(client_.start_fade().is_null());
-  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  EXPECT_EQ(kFadeOutDelay, client_.delay());
 }
 
 // Tests that the fade effect is animated.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest, FadeAnimated) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   // Scroll to make the scrollbars visible.
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate(false);
   scrollbar_controller_->DidScrollEnd();
 
   // Appearance is instant.
   ExpectScrollbarsOpacity(1);
 
-  // An animation should have been enqueued.
-  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  // An fade out animation should have been enqueued.
+  EXPECT_EQ(kFadeOutDelay, client_.delay());
   EXPECT_FALSE(client_.start_fade().is_null());
   client_.start_fade().Run();
 
   // Test that at half the fade duration time, the opacity is at half.
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(1);
 
-  time += kFadeDuration / 2;
+  time += kFadeOutDuration / 2;
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(.5f);
 
-  time += kFadeDuration / 2;
+  time += kFadeOutDuration / 2;
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(0);
 }
 
 // Tests that the controller tells the client when the scrollbars hide/show.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest, NotifyChangedVisibility) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   EXPECT_CALL(client_, DidChangeScrollbarVisibility()).Times(1);
   // Scroll to make the scrollbars visible.
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate(false);
   EXPECT_FALSE(scrollbar_controller_->ScrollbarsHidden());
   Mock::VerifyAndClearExpectations(&client_);
 
   scrollbar_controller_->DidScrollEnd();
 
-  // Play out the fade animation. We shouldn't notify that the scrollbars are
-  // hidden until the animation is completly over. We can (but don't have to)
-  // notify during the animation that the scrollbars are still visible.
+  // Play out the fade out animation. We shouldn't notify that the scrollbars
+  // are hidden until the animation is completly over. We can (but don't have
+  // to) notify during the animation that the scrollbars are still visible.
   EXPECT_CALL(client_, DidChangeScrollbarVisibility()).Times(0);
   ASSERT_FALSE(client_.start_fade().is_null());
   client_.start_fade().Run();
   scrollbar_controller_->Animate(time);
-  time += kFadeDuration / 4;
+  time += kFadeOutDuration / 4;
   EXPECT_FALSE(scrollbar_controller_->ScrollbarsHidden());
   scrollbar_controller_->Animate(time);
-  time += kFadeDuration / 4;
+  time += kFadeOutDuration / 4;
   EXPECT_FALSE(scrollbar_controller_->ScrollbarsHidden());
   scrollbar_controller_->Animate(time);
-  time += kFadeDuration / 4;
+  time += kFadeOutDuration / 4;
   EXPECT_FALSE(scrollbar_controller_->ScrollbarsHidden());
   scrollbar_controller_->Animate(time);
   ExpectScrollbarsOpacity(.25f);
   Mock::VerifyAndClearExpectations(&client_);
 
   EXPECT_CALL(client_, DidChangeScrollbarVisibility()).Times(1);
-  time += kFadeDuration / 4;
+  time += kFadeOutDuration / 4;
   scrollbar_controller_->Animate(time);
   EXPECT_TRUE(scrollbar_controller_->ScrollbarsHidden());
   ExpectScrollbarsOpacity(0);
   Mock::VerifyAndClearExpectations(&client_);
 
   // Calling DidScrollUpdate without a begin (i.e. update from commit) should
   // also notify.
   EXPECT_CALL(client_, DidChangeScrollbarVisibility()).Times(1);
   scrollbar_controller_->DidScrollUpdate(false);
   EXPECT_FALSE(scrollbar_controller_->ScrollbarsHidden());
@@ skipping 82 matching lines @@
       HORIZONTAL, kDefaultMouseMoveDistanceToTriggerAnimation);
   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 animation should have been enqueued.
+  // An fade out animation should have been enqueued.
   EXPECT_FALSE(client_.start_fade().is_null());
-  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  EXPECT_EQ(kFadeOutDelay, 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(false);
@@ skipping 69 matching lines @@
 
   // 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 animation should have been enqueued.
+  // An fade out animation should have been enqueued.
   EXPECT_FALSE(client_.start_fade().is_null());
-  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  EXPECT_EQ(kFadeOutDelay, 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);
 
   // Scroll to make the scrollbars visible.
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate(false);
   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 animation should have been enqueued.
+  // An fade out animation should have been enqueued.
   EXPECT_FALSE(client_.start_fade().is_null());
-  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  EXPECT_EQ(kFadeOutDelay, client_.delay());
+}
+
+// Scrollbars should schedule a delay show when mouse hover hidden scrollbar.
+TEST_F(ScrollbarAnimationControllerAuraOverlayTest, BasicMouseHoverShow) {
+  base::TimeTicks time;
+  time += base::TimeDelta::FromSeconds(1);
+
+  // Move mouse over scrollbar.
+  scrollbar_controller_->DidMouseMoveNear(VERTICAL, 0);
+
+  // An show animation should have been enqueued.
+  EXPECT_FALSE(client_.start_fade().is_null());
+  EXPECT_FALSE(client_.start_fade().IsCancelled());
+  EXPECT_EQ(kShowDelay, client_.delay());
+
+  // Play the delay animation.
+  client_.start_fade().Run();
+  EXPECT_FALSE(scrollbar_controller_->ScrollbarsHidden());
+}
+
+// Scrollbars should not schedule a new delay show when the mouse hovers inside
+// a scrollbar already scheduled a delay show.
+TEST_F(ScrollbarAnimationControllerAuraOverlayTest,
+       MouseHoverScrollbarAndMoveInside) {
+  base::TimeTicks time;
+  time += base::TimeDelta::FromSeconds(1);
+
+  // Move mouse over scrollbar.
+  scrollbar_controller_->DidMouseMoveNear(VERTICAL, 0);
+
+  // An show animation should have been enqueued.
+  EXPECT_FALSE(client_.start_fade().is_null());
+  EXPECT_FALSE(client_.start_fade().IsCancelled());
+  EXPECT_EQ(kShowDelay, client_.delay());
+
+  base::Closure& fade = client_.start_fade();
+  // Move mouse inside scrollbar. should not post a new show.
+  scrollbar_controller_->DidMouseMoveNear(
+      VERTICAL, kMouseMoveDistanceToTriggerShow - kThumbThickness - 1);
+
+  EXPECT_TRUE(fade.Equals(client_.start_fade()));
+}
+
+// Scrollbars should cancel delay show when mouse hover hidden scrollbar then
+// move out.
+TEST_F(ScrollbarAnimationControllerAuraOverlayTest,
+       MouseHoverThenOutShouldCancelShow) {
+  base::TimeTicks time;
+  time += base::TimeDelta::FromSeconds(1);
+
+  // Move mouse over scrollbar.
+  scrollbar_controller_->DidMouseMoveNear(VERTICAL, 0);
+
+  // An show animation should have been enqueued.
+  EXPECT_FALSE(client_.start_fade().is_null());
+  EXPECT_FALSE(client_.start_fade().IsCancelled());
+  EXPECT_EQ(kShowDelay, client_.delay());
+
+  // Move mouse out of scrollbar，delay show should be canceled.
+  scrollbar_controller_->DidMouseMoveNear(
+      VERTICAL, kMouseMoveDistanceToTriggerShow - kThumbThickness);
+  EXPECT_TRUE(client_.start_fade().is_null() ||
+              client_.start_fade().IsCancelled());
 }
 
 class ScrollbarAnimationControllerAndroidTest
     : public testing::Test,
       public ScrollbarAnimationControllerClient {
  public:
   ScrollbarAnimationControllerAndroidTest()
       : host_impl_(&task_runner_provider_, &task_graph_runner_),
         did_request_redraw_(false),
         did_request_animate_(false) {}
 
   void PostDelayedScrollbarAnimationTask(const base::Closure& start_fade,
                                          base::TimeDelta delay) override {
     start_fade_ = start_fade;
     delay_ = delay;
   }
   void SetNeedsRedrawForScrollbarAnimation() override {
     did_request_redraw_ = true;
   }
   void SetNeedsAnimateForScrollbarAnimation() override {
     did_request_animate_ = true;
   }
   ScrollbarSet ScrollbarsFor(int scroll_layer_id) const override {
     return host_impl_.ScrollbarsFor(scroll_layer_id);
   }
   void DidChangeScrollbarVisibility() override {}
 
  protected:
   void SetUp() override {
-    const int kThumbThickness = 10;
     const int kTrackStart = 0;
     const bool kIsLeftSideVerticalScrollbar = false;
     const bool kIsOverlayScrollbar = true;  // Allow opacity animations.
 
     std::unique_ptr<LayerImpl> scroll_layer =
         LayerImpl::Create(host_impl_.active_tree(), 1);
     std::unique_ptr<SolidColorScrollbarLayerImpl> scrollbar =
         SolidColorScrollbarLayerImpl::Create(
             host_impl_.active_tree(), 2, orientation(), kThumbThickness,
             kTrackStart, kIsLeftSideVerticalScrollbar, kIsOverlayScrollbar);
@@ skipping 438 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