Disable overlay scrollbars in Blink when hidden by the compositor.

cc/input/scrollbar_animation_controller_thinning_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_thinning.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 {
 
 // These constants are hard-coded and should match the values in
 // scrollbar_animation_controller_thinning.cc.
 const float kIdleThicknessScale = 0.4f;
 const float kDefaultMouseMoveDistanceToTriggerAnimation = 25.f;
 
-class ScrollbarAnimationControllerThinningTest
-    : public testing::Test,
-      public ScrollbarAnimationControllerClient {
+class MockScrollbarAnimationControllerClient
+    : public ScrollbarAnimationControllerClient {
  public:
-  ScrollbarAnimationControllerThinningTest()
-      : host_impl_(&task_runner_provider_,
-                   &task_graph_runner_) {}
+  explicit MockScrollbarAnimationControllerClient(LayerTreeHostImpl* host_impl)
+      : host_impl_(host_impl) {}
+  virtual ~MockScrollbarAnimationControllerClient() {}
 
   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 SetNeedsRedrawForScrollbarAnimation() override {}
+  void SetNeedsAnimateForScrollbarAnimation() override {}
+  ScrollbarSet ScrollbarsFor(int scroll_layer_id) const override {
+    return host_impl_->ScrollbarsFor(scroll_layer_id);
   }
-  void SetNeedsAnimateForScrollbarAnimation() override {
-    did_request_animate_ = true;
-  }
-  ScrollbarSet ScrollbarsFor(int scroll_layer_id) const override {
-    return host_impl_.ScrollbarsFor(scroll_layer_id);
-  }
+  MOCK_METHOD0(DidChangeScrollbarVisibility, void());
+
+  base::Closure& start_fade() { return start_fade_; }
+  base::TimeDelta& delay() { return delay_; }
+
+ private:
+  base::Closure start_fade_;
+  base::TimeDelta delay_;
+  LayerTreeHostImpl* host_impl_;
+};
+
+class ScrollbarAnimationControllerThinningTest : public testing::Test {
+ public:
+  ScrollbarAnimationControllerThinningTest()
+      : host_impl_(&task_runner_provider_, &task_graph_runner_),
+        client_(&host_impl_) {}
 
  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 kThinningDuration = base::TimeDelta::FromSeconds(2);
 
   void SetUp() override {
     std::unique_ptr<LayerImpl> scroll_layer =
@@ skipping 20 matching lines @@
     clip_layer_->test_properties()->AddChild(std::move(scroll_layer));
     host_impl_.active_tree()->SetRootLayerForTesting(std::move(clip));
 
     scrollbar_layer_->SetScrollLayerId(scroll_layer_ptr->id());
     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_ = ScrollbarAnimationControllerThinning::Create(
-        scroll_layer_ptr->id(), this, kDelayBeforeStarting,
+        scroll_layer_ptr->id(), &client_, kDelayBeforeStarting,
         kResizeDelayBeforeStarting, kFadeDuration, kThinningDuration);
   }
 
   FakeImplTaskRunnerProvider task_runner_provider_;
   TestTaskGraphRunner task_graph_runner_;
   FakeLayerTreeHostImpl host_impl_;
   std::unique_ptr<ScrollbarAnimationControllerThinning> scrollbar_controller_;
   LayerImpl* clip_layer_;
   SolidColorScrollbarLayerImpl* scrollbar_layer_;
-
-  base::Closure start_fade_;
-  base::TimeDelta delay_;
-  bool did_request_redraw_;
-  bool did_request_animate_;
+  NiceMock<MockScrollbarAnimationControllerClient> client_;
 };
 
 // Check initialization of scrollbar. Should start off invisible and thin.
 TEST_F(ScrollbarAnimationControllerThinningTest, Idle) {
   EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
   EXPECT_FLOAT_EQ(0.4f, scrollbar_layer_->thumb_thickness_scale_factor());
 }
 
 // Check that scrollbar appears again when the layer becomes scrollable.
 TEST_F(ScrollbarAnimationControllerThinningTest, AppearOnResize) {
@@ skipping 57 matching lines @@
   scrollbar_controller_->DidScrollBegin();
   EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
 
   scrollbar_controller_->DidScrollUpdate(false);
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
 
   scrollbar_controller_->DidScrollEnd();
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
 
   // An animation should have been enqueued.
-  EXPECT_EQ(kDelayBeforeStarting, delay_);
-  EXPECT_FALSE(start_fade_.is_null());
-  start_fade_.Run();
+  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  EXPECT_FALSE(client_.start_fade().is_null());
+  client_.start_fade().Run();
 
   // Scrollbar should fade out over kFadeDuration.
   scrollbar_controller_->Animate(time);
   time += kFadeDuration;
   scrollbar_controller_->Animate(time);
 
   EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
 }
 
 // Scroll content. Move the mouse near the scrollbar and confirm it becomes
 // thick. Ensure it fades out after that.
 TEST_F(ScrollbarAnimationControllerThinningTest, MoveNearAndFadeOut) {
   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, delay_);
-  EXPECT_FALSE(start_fade_.is_null());
+  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  EXPECT_FALSE(client_.start_fade().is_null());
 
   // Now move the mouse near the scrollbar. This should cancel the currently
   // queued fading animation and start animating thickness.
   scrollbar_controller_->DidMouseMoveNear(1);
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   scrollbar_layer_->thumb_thickness_scale_factor());
-  EXPECT_TRUE(start_fade_.IsCancelled());
+  EXPECT_TRUE(client_.start_fade().IsCancelled());
 
   // Scrollbar should become thick.
   scrollbar_controller_->Animate(time);
   time += kThinningDuration;
   scrollbar_controller_->Animate(time);
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->thumb_thickness_scale_factor());
 
   // Once the thickening animation is complete, it should enqueue the delayed
   // fade animation.
-  EXPECT_FALSE(start_fade_.is_null());
-  EXPECT_FALSE(start_fade_.IsCancelled());
+  EXPECT_FALSE(client_.start_fade().is_null());
+  EXPECT_FALSE(client_.start_fade().IsCancelled());
 }
 
 // Scroll content. Move the mouse over the scrollbar and confirm it becomes
 // thick. Ensure it fades out after that.
 TEST_F(ScrollbarAnimationControllerThinningTest, MoveOverAndFadeOut) {
   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, delay_);
-  EXPECT_FALSE(start_fade_.is_null());
+  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  EXPECT_FALSE(client_.start_fade().is_null());
 
   // Now move the mouse over the scrollbar. This should cancel the currently
   // queued fading animation and start animating thickness.
   scrollbar_controller_->DidMouseMoveNear(0);
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   scrollbar_layer_->thumb_thickness_scale_factor());
-  EXPECT_TRUE(start_fade_.IsCancelled());
+  EXPECT_TRUE(client_.start_fade().IsCancelled());
 
   // Scrollbar should become thick.
   scrollbar_controller_->Animate(time);
   time += kThinningDuration;
   scrollbar_controller_->Animate(time);
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->thumb_thickness_scale_factor());
 
   // Once the thickening animation is complete, it should enqueue the delayed
   // fade animation.
-  EXPECT_FALSE(start_fade_.is_null());
-  EXPECT_FALSE(start_fade_.IsCancelled());
+  EXPECT_FALSE(client_.start_fade().is_null());
+  EXPECT_FALSE(client_.start_fade().IsCancelled());
 }
 
 // Make sure a scrollbar captured before the thickening animation doesn't try
 // to fade out.
 TEST_F(ScrollbarAnimationControllerThinningTest,
        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, delay_);
-  EXPECT_FALSE(start_fade_.is_null());
+  EXPECT_EQ(kDelayBeforeStarting, 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(0);
   scrollbar_controller_->DidMouseDown();
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->thumb_thickness_scale_factor());
 
   // The fade animation should have been cancelled.
-  EXPECT_FALSE(start_fade_.is_null());
-  EXPECT_TRUE(start_fade_.IsCancelled());
+  EXPECT_FALSE(client_.start_fade().is_null());
+  EXPECT_TRUE(client_.start_fade().IsCancelled());
 }
 
 // Make sure a scrollbar captured after a thickening animation doesn't try to
 // fade out.
 TEST_F(ScrollbarAnimationControllerThinningTest, 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, delay_);
-  EXPECT_FALSE(start_fade_.is_null());
+  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  EXPECT_FALSE(client_.start_fade().is_null());
 
   // Now move the mouse over the scrollbar and animate it until it's thick.
   scrollbar_controller_->DidMouseMoveNear(0);
   scrollbar_controller_->Animate(time);
   time += kThinningDuration;
   scrollbar_controller_->Animate(time);
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->thumb_thickness_scale_factor());
 
   // Since the scrollbar became thick, it should have queued up a fade.
-  EXPECT_FALSE(start_fade_.is_null());
-  EXPECT_FALSE(start_fade_.IsCancelled());
+  EXPECT_FALSE(client_.start_fade().is_null());
+  EXPECT_FALSE(client_.start_fade().IsCancelled());
 
   // Make sure capturing the scrollbar stops the fade.
   scrollbar_controller_->DidMouseDown();
-  EXPECT_FALSE(start_fade_.is_null());
-  EXPECT_TRUE(start_fade_.IsCancelled());
+  EXPECT_FALSE(client_.start_fade().is_null());
+  EXPECT_TRUE(client_.start_fade().IsCancelled());
 }
 
 // Make sure releasing a captured scrollbar causes it to fade out.
 TEST_F(ScrollbarAnimationControllerThinningTest, FadeAfterReleased) {
   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, delay_);
-  EXPECT_FALSE(start_fade_.is_null());
+  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  EXPECT_FALSE(client_.start_fade().is_null());
 
   // Now move the mouse over the scrollbar and capture it.
   scrollbar_controller_->DidMouseMoveNear(0);
   scrollbar_controller_->DidMouseDown();
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->thumb_thickness_scale_factor());
 
   // Since the scrollbar became thick, it should have queued up a fade.
-  EXPECT_FALSE(start_fade_.is_null());
-  EXPECT_TRUE(start_fade_.IsCancelled());
+  EXPECT_FALSE(client_.start_fade().is_null());
+  EXPECT_TRUE(client_.start_fade().IsCancelled());
 
   scrollbar_controller_->DidMouseUp();
-  EXPECT_FALSE(start_fade_.is_null());
-  EXPECT_FALSE(start_fade_.IsCancelled());
+  EXPECT_FALSE(client_.start_fade().is_null());
+  EXPECT_FALSE(client_.start_fade().IsCancelled());
 }
 
 // Make sure moving near a scrollbar while it's fading out causes it to reset
 // the opacity and thicken.
 TEST_F(ScrollbarAnimationControllerThinningTest, MoveNearScrollbarWhileFading) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate(false);
   scrollbar_controller_->DidScrollEnd();
 
   // An animation should have been enqueued. Start it.
-  EXPECT_EQ(kDelayBeforeStarting, delay_);
-  EXPECT_FALSE(start_fade_.is_null());
-  start_fade_.Run();
+  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  EXPECT_FALSE(client_.start_fade().is_null());
+  client_.start_fade().Run();
 
   scrollbar_controller_->Animate(time);
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
 
   // Proceed half way through the fade out animation.
   time += kFadeDuration / 2;
   scrollbar_controller_->Animate(time);
   EXPECT_FLOAT_EQ(0.5f, scrollbar_layer_->Opacity());
 
   // Now move the mouse near the scrollbar. It should reset opacity to 1
@@ skipping 22 matching lines @@
 
   // Move mouse over the scrollbar.
   scrollbar_controller_->DidMouseMoveNear(0);
   scrollbar_controller_->Animate(time);
   time += kThinningDuration;
   scrollbar_controller_->Animate(time);
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->thumb_thickness_scale_factor());
 
   // A fade animation should have been enqueued. Start it.
-  EXPECT_EQ(kDelayBeforeStarting, delay_);
-  EXPECT_FALSE(start_fade_.is_null());
-  start_fade_.Run();
+  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  EXPECT_FALSE(client_.start_fade().is_null());
+  client_.start_fade().Run();
 
   scrollbar_controller_->Animate(time);
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
 
   // Proceed half way through the fade out animation.
   time += kFadeDuration / 2;
   scrollbar_controller_->Animate(time);
   EXPECT_FLOAT_EQ(0.5f, scrollbar_layer_->Opacity());
 
   // Now capture the scrollbar. It should reset opacity to 1 instantly.
@@ skipping 13 matching lines @@
 
   // Move mouse over the scrollbar.
   scrollbar_controller_->DidMouseMoveNear(0);
   scrollbar_controller_->Animate(time);
   time += kThinningDuration;
   scrollbar_controller_->Animate(time);
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->thumb_thickness_scale_factor());
 
   // A fade animation should have been enqueued. Start it.
-  EXPECT_EQ(kDelayBeforeStarting, delay_);
-  EXPECT_FALSE(start_fade_.is_null());
-  start_fade_.Run();
+  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  EXPECT_FALSE(client_.start_fade().is_null());
+  client_.start_fade().Run();
   scrollbar_controller_->Animate(time);
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
 
   // Fade the scrollbar out completely.
   time += kFadeDuration;
   scrollbar_controller_->Animate(time);
   EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->thumb_thickness_scale_factor());
 
-  start_fade_.Reset();
+  client_.start_fade().Reset();
 
   // Now try to capture the scrollbar. It shouldn't do anything since it's
   // completely faded out.
   scrollbar_controller_->DidMouseDown();
   EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->thumb_thickness_scale_factor());
-  EXPECT_TRUE(start_fade_.is_null());
+  EXPECT_TRUE(client_.start_fade().is_null());
 
   // Similarly, releasing the scrollbar should have no effect.
   scrollbar_controller_->DidMouseUp();
   EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->thumb_thickness_scale_factor());
-  EXPECT_TRUE(start_fade_.is_null());
+  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(ScrollbarAnimationControllerThinningTest, ScrollWithMouseNear) {
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   scrollbar_controller_->DidMouseMoveNear(1);
   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(kIdleThicknessScale,
                   scrollbar_layer_->thumb_thickness_scale_factor());
 
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate(false);
 
   // Now that we've received a scroll, we should be thick without an animation.
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->thumb_thickness_scale_factor());
 
   // An animation for the fade should have been enqueued.
   scrollbar_controller_->DidScrollEnd();
-  EXPECT_EQ(kDelayBeforeStarting, delay_);
-  EXPECT_FALSE(start_fade_.is_null());
+  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  EXPECT_FALSE(client_.start_fade().is_null());
 
-  start_fade_.Run();
+  client_.start_fade().Run();
   scrollbar_controller_->Animate(time);
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->thumb_thickness_scale_factor());
 
   // Scrollbar should still be thick, even though the scrollbar fades out.
   time += kFadeDuration;
   scrollbar_controller_->Animate(time);
   EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->thumb_thickness_scale_factor());
 }
@@ skipping 344 matching lines @@
 
   time += kThinningDuration / 2;
   scrollbar_controller_->Animate(time);
   EXPECT_FLOAT_EQ(kIdleThicknessScale,
                   scrollbar_layer_->thumb_thickness_scale_factor());
 }
 
 // Tests that main thread scroll updates immediatley queue a fade animation
 // without requiring a ScrollEnd.
 TEST_F(ScrollbarAnimationControllerThinningTest, MainThreadScrollQueuesFade) {
-  ASSERT_TRUE(start_fade_.is_null());
+  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
   // (which will never come).
   scrollbar_controller_->DidScrollUpdate(false);
-  EXPECT_FALSE(start_fade_.is_null());
-  EXPECT_EQ(kDelayBeforeStarting, delay_);
+  EXPECT_FALSE(client_.start_fade().is_null());
+  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
 
-  start_fade_.Reset();
+  client_.start_fade().Reset();
 
   // If we got a ScrollBegin, we shouldn't schedule the fade animation until we
   // get a corresponding ScrollEnd.
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate(false);
-  EXPECT_TRUE(start_fade_.is_null());
+  EXPECT_TRUE(client_.start_fade().is_null());
   scrollbar_controller_->DidScrollEnd();
-  EXPECT_FALSE(start_fade_.is_null());
-  EXPECT_EQ(kDelayBeforeStarting, delay_);
+  EXPECT_FALSE(client_.start_fade().is_null());
+  EXPECT_EQ(kDelayBeforeStarting, 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(ScrollbarAnimationControllerThinningTest, ResizeFadeDuration) {
-  ASSERT_TRUE(delay_.is_zero());
+  ASSERT_TRUE(client_.delay().is_zero());
 
   scrollbar_controller_->DidScrollUpdate(true);
-  EXPECT_FALSE(start_fade_.is_null());
-  EXPECT_EQ(kResizeDelayBeforeStarting, delay_);
+  EXPECT_FALSE(client_.start_fade().is_null());
+  EXPECT_EQ(kResizeDelayBeforeStarting, client_.delay());
 
-  delay_ = base::TimeDelta();
+  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(start_fade_.is_null());
-  EXPECT_EQ(kDelayBeforeStarting, delay_);
+  EXPECT_FALSE(client_.start_fade().is_null());
+  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
 }
 
 // Tests that the fade effect is animated.
 TEST_F(ScrollbarAnimationControllerThinningTest, FadeAnimated) {
   // Scroll to make the scrollbars visible.
   scrollbar_controller_->DidScrollBegin();
   scrollbar_controller_->DidScrollUpdate(false);
   scrollbar_controller_->DidScrollEnd();
 
   // Appearance is instant.
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
 
   // An animation should have been enqueued.
-  EXPECT_EQ(kDelayBeforeStarting, delay_);
-  EXPECT_FALSE(start_fade_.is_null());
-  start_fade_.Run();
+  EXPECT_EQ(kDelayBeforeStarting, client_.delay());
+  EXPECT_FALSE(client_.start_fade().is_null());
+  client_.start_fade().Run();
 
   base::TimeTicks time;
   time += base::TimeDelta::FromSeconds(1);
 
   // Test that at half the fade duration time, the opacity is at half.
   scrollbar_controller_->Animate(time);
   EXPECT_FLOAT_EQ(1.0f, scrollbar_layer_->Opacity());
 
   time += kFadeDuration / 2;
   scrollbar_controller_->Animate(time);
   EXPECT_FLOAT_EQ(0.5f, scrollbar_layer_->Opacity());
 
   time += kFadeDuration / 2;
   scrollbar_controller_->Animate(time);
   EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
 }
 
+// Tests that the controller tells the client when the scrollbars hide/show.
+TEST_F(ScrollbarAnimationControllerThinningTest, 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.
+  EXPECT_CALL(client_, DidChangeScrollbarVisibility()).Times(0);
+  ASSERT_FALSE(client_.start_fade().is_null());
+  client_.start_fade().Run();
+  scrollbar_controller_->Animate(time);
+  time += kFadeDuration / 4;
+  EXPECT_FALSE(scrollbar_controller_->ScrollbarsHidden());
+  scrollbar_controller_->Animate(time);
+  time += kFadeDuration / 4;
+  EXPECT_FALSE(scrollbar_controller_->ScrollbarsHidden());
+  scrollbar_controller_->Animate(time);
+  time += kFadeDuration / 4;
+  EXPECT_FALSE(scrollbar_controller_->ScrollbarsHidden());
+  scrollbar_controller_->Animate(time);
+  EXPECT_FLOAT_EQ(0.25f, scrollbar_layer_->Opacity());
+  Mock::VerifyAndClearExpectations(&client_);
+
+  EXPECT_CALL(client_, DidChangeScrollbarVisibility()).Times(1);
+  time += kFadeDuration / 4;
+  scrollbar_controller_->Animate(time);
+  EXPECT_TRUE(scrollbar_controller_->ScrollbarsHidden());
+  EXPECT_FLOAT_EQ(0.0f, scrollbar_layer_->Opacity());
+  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());
+  Mock::VerifyAndClearExpectations(&client_);
+}
+
 }  // namespace
 }  // namespace cc