change overlay scrollbar hover show to hover fade in

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 float kMouseMoveDistanceToTriggerFadeIn =
+    ScrollbarAnimationController::kMouseMoveDistanceToTriggerFadeIn;
 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 25 matching lines @@
 
   void ExpectScrollbarsOpacity(float opacity) {
     EXPECT_FLOAT_EQ(opacity, v_scrollbar_layer_->Opacity());
     EXPECT_FLOAT_EQ(opacity, h_scrollbar_layer_->Opacity());
   }
 
  protected:
   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 kFadeInDuration = base::TimeDelta::FromSeconds(3);
   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());
@@ skipping 23 matching lines @@
     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_, kShowDelay, kFadeOutDelay,
-            kResizeFadeOutDelay, kFadeOutDuration, kThinningDuration);
+            kResizeFadeOutDelay, kFadeInDuration, 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 869 matching lines @@
               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(kFadeOutDelay, client_.delay());
 }
 
-// Scrollbars should schedule a delay show when mouse hover the show scrollbar
-// region of a hidden scrollbar.
-TEST_F(ScrollbarAnimationControllerAuraOverlayTest, BasicMouseHoverShow) {
+// 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 show scrollbar region of scrollbar.
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL,
-                                          kMouseMoveDistanceToTriggerShow - 1);
+  // Move mouse hover the fade in scrollbar region of scrollbar.
+  scrollbar_controller_->DidMouseMoveNear(
+      VERTICAL, kMouseMoveDistanceToTriggerFadeIn - 1);
 
-  // An show animation should have been enqueued.
+  // An fade in 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_TRUE(client_.start_fade().IsCancelled());
+
+  scrollbar_controller_->Animate(time);
+  time += kFadeInDuration;

[bokan, 2017/04/13 14:38:14]

Please add a step in here before the animation finishes to ensure we're actually
animating the fade in.

[chaopeng, 2017/04/13 15:15:37]

Done.

+  scrollbar_controller_->Animate(time);
+
   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.
+// 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 show scrollbar region of scrollbar.
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL,
-                                          kMouseMoveDistanceToTriggerShow - 1);
+  // Move mouse hover the fade in scrollbar region of scrollbar.
+  scrollbar_controller_->DidMouseMoveNear(
+      VERTICAL, kMouseMoveDistanceToTriggerFadeIn - 1);
 
-  // An show animation should have been enqueued.
+  // An fade in 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 still hover the show scrollbar region of scrollbar should not
+  // Move mouse still hover the fade in scrollbar region of scrollbar should not
   // post a new show.
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL,
-                                          kMouseMoveDistanceToTriggerShow - 2);
+  scrollbar_controller_->DidMouseMoveNear(
+      VERTICAL, kMouseMoveDistanceToTriggerFadeIn - 2);
 
   EXPECT_TRUE(fade.Equals(client_.start_fade()));
 }
 
 // Scrollbars should cancel delay show when mouse hover hidden scrollbar then
 // move far away.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest,
        MouseHoverThenOutShouldCancelShow) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
-  // Move mouse hover the show scrollbar region of scrollbar.
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL,
-                                          kMouseMoveDistanceToTriggerShow - 1);
+  // Move mouse hover the fade in scrollbar region of scrollbar.
+  scrollbar_controller_->DidMouseMoveNear(
+      VERTICAL, kMouseMoveDistanceToTriggerFadeIn - 1);
 
-  // An show animation should have been enqueued.
+  // An fade in 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 far away，delay show should be canceled.
   scrollbar_controller_->DidMouseMoveNear(VERTICAL,
-                                          kMouseMoveDistanceToTriggerShow);
+                                          kMouseMoveDistanceToTriggerFadeIn);
   EXPECT_TRUE(client_.start_fade().is_null() ||
               client_.start_fade().IsCancelled());
 }
 
 // Scrollbars should cancel delay show when mouse hover hidden scrollbar then
 // move out of window.
 TEST_F(ScrollbarAnimationControllerAuraOverlayTest,
        MouseHoverThenLeaveShouldCancelShowThenEnterShouldShow) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
-  // Move mouse hover the show scrollbar region of scrollbar.
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL,
-                                          kMouseMoveDistanceToTriggerShow - 1);
+  // Move mouse hover the fade in scrollbar region of scrollbar.
+  scrollbar_controller_->DidMouseMoveNear(
+      VERTICAL, kMouseMoveDistanceToTriggerFadeIn - 1);
 
-  // An show animation should have been enqueued.
+  // An fade in 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 window，delay show should be canceled.
   scrollbar_controller_->DidMouseLeave();
   EXPECT_TRUE(client_.start_fade().is_null() ||
               client_.start_fade().IsCancelled());
 
-  // Move mouse hover the show scrollbar region of scrollbar.
-  scrollbar_controller_->DidMouseMoveNear(VERTICAL,
-                                          kMouseMoveDistanceToTriggerShow - 1);
+  // Move mouse hover the fade in scrollbar region of scrollbar.
+  scrollbar_controller_->DidMouseMoveNear(
+      VERTICAL, kMouseMoveDistanceToTriggerFadeIn - 1);
 
-  // An show animation should have been enqueued.
+  // An fade in 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_TRUE(client_.start_fade().IsCancelled());
+
+  scrollbar_controller_->Animate(time);
+  time += kFadeInDuration;
+  scrollbar_controller_->Animate(time);
+
   EXPECT_FALSE(scrollbar_controller_->ScrollbarsHidden());
 }
 
 class ScrollbarAnimationControllerAndroidTest
     : public testing::Test,
       public ScrollbarAnimationControllerClient {
  public:
   ScrollbarAnimationControllerAndroidTest()
       : host_impl_(&task_runner_provider_, &task_graph_runner_),
         did_request_redraw_(false),
@@ skipping 473 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