Add flag to hide scrollbars completely.

cc/trees/layer_tree_host_impl_unittest.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 2752 matching lines @@
     host_impl_->active_tree()->DidBecomeActive();
     DrawFrame();
   }
 
   void RunTest(LayerTreeSettings::ScrollbarAnimator animator) {
     LayerTreeSettings settings = DefaultSettings();
     settings.scrollbar_animator = animator;
     settings.scrollbar_fade_delay_ms = 20;
     settings.scrollbar_fade_duration_ms = 20;
 
+    // If no animator is set, scrollbar won't show and no animation is expected.
+    bool expecting_animations = animator != LayerTreeSettings::NO_ANIMATOR;
+
     SetupLayers(settings);
 
     base::TimeTicks fake_now = base::TimeTicks::Now();
 
-    // A task will be posted to fade the initial scrollbar.
-    EXPECT_FALSE(did_request_next_frame_);
-    EXPECT_FALSE(did_request_redraw_);
-    EXPECT_FALSE(animation_task_.Equals(base::Closure()));
-    requested_animation_delay_ = base::TimeDelta();
-    animation_task_ = base::Closure();
+    if (expecting_animations) {
+      // A task will be posted to fade the initial scrollbar.
+      EXPECT_FALSE(did_request_next_frame_);
+      EXPECT_FALSE(did_request_redraw_);
+      EXPECT_FALSE(animation_task_.Equals(base::Closure()));
+      requested_animation_delay_ = base::TimeDelta();
+      animation_task_ = base::Closure();
+    } else {
+      EXPECT_FALSE(did_request_next_frame_);
+      EXPECT_FALSE(did_request_redraw_);
+      EXPECT_TRUE(animation_task_.Equals(base::Closure()));
+      EXPECT_EQ(base::TimeDelta(), requested_animation_delay_);
+    }
 
     // If no scroll happened during a scroll gesture, it should have no effect.
     host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                             InputHandler::WHEEL);
     host_impl_->ScrollEnd(EndState().get());
     EXPECT_FALSE(did_request_next_frame_);
     EXPECT_FALSE(did_request_redraw_);
     EXPECT_EQ(base::TimeDelta(), requested_animation_delay_);
     EXPECT_TRUE(animation_task_.Equals(base::Closure()));
 
@@ skipping 17 matching lines @@
     host_impl_->ScrollBy(UpdateState(gfx::Point(), gfx::Vector2dF(0, 5)).get());
     EXPECT_FALSE(did_request_next_frame_);
     EXPECT_TRUE(did_request_redraw_);
     did_request_redraw_ = false;
     EXPECT_EQ(base::TimeDelta(), requested_animation_delay_);
     EXPECT_TRUE(animation_task_.Equals(base::Closure()));
 
     host_impl_->ScrollEnd(EndState().get());
     EXPECT_FALSE(did_request_next_frame_);
     EXPECT_FALSE(did_request_redraw_);
-    EXPECT_EQ(base::TimeDelta::FromMilliseconds(20),
-              requested_animation_delay_);
-    EXPECT_FALSE(animation_task_.Equals(base::Closure()));
+    if (expecting_animations) {
+      EXPECT_EQ(base::TimeDelta::FromMilliseconds(20),
+                requested_animation_delay_);
+      EXPECT_FALSE(animation_task_.Equals(base::Closure()));
+    } else {
+      EXPECT_EQ(base::TimeDelta(), requested_animation_delay_);
+      EXPECT_TRUE(animation_task_.Equals(base::Closure()));
+    }
 
-    // Before the scrollbar animation begins, we should not get redraws.
-    begin_frame_args =
-        CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, fake_now);
-    host_impl_->WillBeginImplFrame(begin_frame_args);
-    host_impl_->Animate();
-    EXPECT_FALSE(did_request_next_frame_);
-    did_request_next_frame_ = false;
-    EXPECT_FALSE(did_request_redraw_);
-    did_request_redraw_ = false;
-    host_impl_->DidFinishImplFrame();
+    if (expecting_animations) {
+      // Before the scrollbar animation begins, we should not get redraws.
+      begin_frame_args =
+          CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, fake_now);
+      host_impl_->WillBeginImplFrame(begin_frame_args);
+      host_impl_->Animate();
+      EXPECT_FALSE(did_request_next_frame_);
+      did_request_next_frame_ = false;
+      EXPECT_FALSE(did_request_redraw_);
+      did_request_redraw_ = false;
+      host_impl_->DidFinishImplFrame();
 
-    // Start the scrollbar animation.
-    fake_now += requested_animation_delay_;
-    requested_animation_delay_ = base::TimeDelta();
-    animation_task_.Run();
-    animation_task_ = base::Closure();
-    EXPECT_TRUE(did_request_next_frame_);
-    did_request_next_frame_ = false;
-    EXPECT_FALSE(did_request_redraw_);
+      // Start the scrollbar animation.
+      fake_now += requested_animation_delay_;
+      requested_animation_delay_ = base::TimeDelta();
+      animation_task_.Run();
+      animation_task_ = base::Closure();
+      EXPECT_TRUE(did_request_next_frame_);
+      did_request_next_frame_ = false;
+      EXPECT_FALSE(did_request_redraw_);
 
-    // After the scrollbar animation begins, we should start getting redraws.
-    begin_frame_args =
-        CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, fake_now);
-    host_impl_->WillBeginImplFrame(begin_frame_args);
-    host_impl_->Animate();
-    EXPECT_TRUE(did_request_next_frame_);
-    did_request_next_frame_ = false;
-    EXPECT_TRUE(did_request_redraw_);
-    did_request_redraw_ = false;
-    EXPECT_EQ(base::TimeDelta(), requested_animation_delay_);
-    EXPECT_TRUE(animation_task_.Equals(base::Closure()));
-    host_impl_->DidFinishImplFrame();
+      // After the scrollbar animation begins, we should start getting redraws.
+      begin_frame_args =
+          CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, fake_now);
+      host_impl_->WillBeginImplFrame(begin_frame_args);
+      host_impl_->Animate();
+      EXPECT_TRUE(did_request_next_frame_);
+      did_request_next_frame_ = false;
+      EXPECT_TRUE(did_request_redraw_);
+      did_request_redraw_ = false;
+      EXPECT_EQ(base::TimeDelta(), requested_animation_delay_);
+      EXPECT_TRUE(animation_task_.Equals(base::Closure()));
+      host_impl_->DidFinishImplFrame();
+    }
 
     // Setting the scroll offset outside a scroll should also cause the
     // scrollbar to appear and to schedule a scrollbar animation.
     if (host_impl_->active_tree()
             ->property_trees()
             ->scroll_tree.UpdateScrollOffsetBaseForTesting(
                 host_impl_->InnerViewportScrollLayer()->id(),
                 gfx::ScrollOffset(5, 5)))
       host_impl_->active_tree()->DidUpdateScrollOffset(
           host_impl_->InnerViewportScrollLayer()->id(),
           host_impl_->InnerViewportScrollLayer()->transform_tree_index());
     EXPECT_FALSE(did_request_next_frame_);
     EXPECT_FALSE(did_request_redraw_);
-    EXPECT_EQ(base::TimeDelta::FromMilliseconds(20),
-              requested_animation_delay_);
-    EXPECT_FALSE(animation_task_.Equals(base::Closure()));
-    requested_animation_delay_ = base::TimeDelta();
-    animation_task_ = base::Closure();
+    if (expecting_animations) {
+      EXPECT_EQ(base::TimeDelta::FromMilliseconds(20),
+                requested_animation_delay_);
+      EXPECT_FALSE(animation_task_.Equals(base::Closure()));
+      requested_animation_delay_ = base::TimeDelta();
+      animation_task_ = base::Closure();
+    } else {
+      EXPECT_EQ(base::TimeDelta(), requested_animation_delay_);
+      EXPECT_TRUE(animation_task_.Equals(base::Closure()));
+    }
 
-    // Scrolling should have stopped the animation, so we should not be getting
-    // redraws.
-    begin_frame_args =
-        CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, fake_now);
-    host_impl_->WillBeginImplFrame(begin_frame_args);
-    host_impl_->Animate();
-    EXPECT_FALSE(did_request_next_frame_);
-    did_request_next_frame_ = false;
-    EXPECT_FALSE(did_request_redraw_);
-    did_request_redraw_ = false;
-    host_impl_->DidFinishImplFrame();
+    if (expecting_animations) {
+      // Scrolling should have stopped the animation, so we should not be
+      // getting redraws.
+      begin_frame_args =
+          CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, fake_now);
+      host_impl_->WillBeginImplFrame(begin_frame_args);
+      host_impl_->Animate();
+      EXPECT_FALSE(did_request_next_frame_);
+      did_request_next_frame_ = false;
+      EXPECT_FALSE(did_request_redraw_);
+      did_request_redraw_ = false;
+      host_impl_->DidFinishImplFrame();
+    }
 
     // Scrollbar animation is not triggered unnecessarily.
     host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                             InputHandler::WHEEL);
     host_impl_->ScrollBy(UpdateState(gfx::Point(), gfx::Vector2dF(5, 0)).get());
     EXPECT_FALSE(did_request_next_frame_);
     EXPECT_TRUE(did_request_redraw_);
     did_request_redraw_ = false;
     EXPECT_EQ(base::TimeDelta(), requested_animation_delay_);
     EXPECT_TRUE(animation_task_.Equals(base::Closure()));
 
     host_impl_->ScrollEnd(EndState().get());
     EXPECT_FALSE(did_request_next_frame_);
     EXPECT_FALSE(did_request_redraw_);
     EXPECT_EQ(base::TimeDelta(), requested_animation_delay_);
     EXPECT_TRUE(animation_task_.Equals(base::Closure()));
 
     // Changing page scale triggers scrollbar animation.
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 1.f, 4.f);
     host_impl_->active_tree()->SetPageScaleOnActiveTree(1.1f);
     EXPECT_FALSE(did_request_next_frame_);
     EXPECT_FALSE(did_request_redraw_);
-    EXPECT_EQ(base::TimeDelta::FromMilliseconds(20),
-              requested_animation_delay_);
-    EXPECT_FALSE(animation_task_.Equals(base::Closure()));
-    requested_animation_delay_ = base::TimeDelta();
-    animation_task_ = base::Closure();
+    if (expecting_animations) {
+      EXPECT_EQ(base::TimeDelta::FromMilliseconds(20),
+                requested_animation_delay_);
+      EXPECT_FALSE(animation_task_.Equals(base::Closure()));
+      requested_animation_delay_ = base::TimeDelta();
+      animation_task_ = base::Closure();
+    } else {
+      EXPECT_EQ(base::TimeDelta(), requested_animation_delay_);
+      EXPECT_TRUE(animation_task_.Equals(base::Closure()));
+    }
   }
 };
 
 TEST_F(LayerTreeHostImplTestScrollbarAnimation, LinearFade) {
   RunTest(LayerTreeSettings::LINEAR_FADE);
 }
 
 TEST_F(LayerTreeHostImplTestScrollbarAnimation, Thinning) {
   RunTest(LayerTreeSettings::THINNING);
 }
 
+TEST_F(LayerTreeHostImplTestScrollbarAnimation, NoAnimator) {
+  RunTest(LayerTreeSettings::NO_ANIMATOR);
+}
+
 class LayerTreeHostImplTestScrollbarOpacity : public LayerTreeHostImplTest {
  protected:
   void RunTest(LayerTreeSettings::ScrollbarAnimator animator) {
     LayerTreeSettings settings = DefaultSettings();
     settings.scrollbar_animator = animator;
     settings.scrollbar_fade_delay_ms = 20;
     settings.scrollbar_fade_duration_ms = 20;
     gfx::Size content_size(100, 100);
 
+    // If no animator is set, scrollbar won't show and no animation is expected.
+    bool expecting_animations = animator != LayerTreeSettings::NO_ANIMATOR;
+
     CreateHostImpl(settings, CreateOutputSurface());
     host_impl_->CreatePendingTree();
     CreateScrollAndContentsLayers(host_impl_->pending_tree(), content_size);
     std::unique_ptr<SolidColorScrollbarLayerImpl> scrollbar =
         SolidColorScrollbarLayerImpl::Create(host_impl_->pending_tree(), 400,
                                              VERTICAL, 10, 0, false, true);
     scrollbar->test_properties()->opacity = 0.f;
     LayerImpl* scroll = host_impl_->pending_tree()->OuterViewportScrollLayer();
     LayerImpl* container =
         host_impl_->pending_tree()->InnerViewportContainerLayer();
     scrollbar->SetScrollLayerId(scroll->id());
     container->test_properties()->AddChild(std::move(scrollbar));
     host_impl_->pending_tree()->PushPageScaleFromMainThread(1.f, 1.f, 1.f);
     host_impl_->pending_tree()->BuildPropertyTreesForTesting();
     host_impl_->ActivateSyncTree();
 
     LayerImpl* active_scrollbar_layer =
         host_impl_->active_tree()->LayerById(400);
 
     EffectNode* active_tree_node =
         host_impl_->active_tree()->property_trees()->effect_tree.Node(
             active_scrollbar_layer->effect_tree_index());
     EXPECT_FLOAT_EQ(active_scrollbar_layer->Opacity(),
                     active_tree_node->opacity);
 
-    host_impl_->ScrollbarAnimationControllerForId(scroll->id())
-        ->DidMouseMoveNear(0);
+    if (expecting_animations) {
+      host_impl_->ScrollbarAnimationControllerForId(scroll->id())
+          ->DidMouseMoveNear(0);
+    } else {
+      EXPECT_EQ(nullptr,
+                host_impl_->ScrollbarAnimationControllerForId(scroll->id()));
+    }
     host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                             InputHandler::WHEEL);
     host_impl_->ScrollBy(UpdateState(gfx::Point(), gfx::Vector2dF(0, 5)).get());
     host_impl_->ScrollEnd(EndState().get());
     host_impl_->CreatePendingTree();
     // To test the case where the effect tree index of scrollbar layer changes,
     // we force the container layer to create a render surface.
     container = host_impl_->pending_tree()->InnerViewportContainerLayer();
     container->test_properties()->force_render_surface = true;
     container->SetBounds(gfx::Size(10, 10));
     host_impl_->pending_tree()->BuildPropertyTreesForTesting();
 
     LayerImpl* pending_scrollbar_layer =
         host_impl_->pending_tree()->LayerById(400);
+    pending_scrollbar_layer->SetNeedsPushProperties();
     EffectNode* pending_tree_node =
         host_impl_->pending_tree()->property_trees()->effect_tree.Node(
             pending_scrollbar_layer->effect_tree_index());
     host_impl_->pending_tree()
         ->property_trees()
         ->always_use_active_tree_opacity_effect_ids.push_back(400);
-    EXPECT_FLOAT_EQ(1.f, active_tree_node->opacity);
-    EXPECT_FLOAT_EQ(1.f, active_scrollbar_layer->Opacity());
+    if (expecting_animations) {
+      EXPECT_FLOAT_EQ(1.f, active_tree_node->opacity);
+      EXPECT_FLOAT_EQ(1.f, active_scrollbar_layer->Opacity());
+    } else {
+      EXPECT_FLOAT_EQ(0.f, active_tree_node->opacity);
+      EXPECT_FLOAT_EQ(0.f, active_scrollbar_layer->Opacity());
+    }
     EXPECT_FLOAT_EQ(0.f, pending_tree_node->opacity);
     host_impl_->ActivateSyncTree();
     active_tree_node =
         host_impl_->active_tree()->property_trees()->effect_tree.Node(
             active_scrollbar_layer->effect_tree_index());
-    EXPECT_FLOAT_EQ(1.f, active_tree_node->opacity);
-    EXPECT_FLOAT_EQ(1.f, active_scrollbar_layer->Opacity());
+    if (expecting_animations) {
+      EXPECT_FLOAT_EQ(1.f, active_tree_node->opacity);
+      EXPECT_FLOAT_EQ(1.f, active_scrollbar_layer->Opacity());
+    } else {
+      EXPECT_FLOAT_EQ(0.f, active_tree_node->opacity);
+      EXPECT_FLOAT_EQ(0.f, active_scrollbar_layer->Opacity());
+    }
   }
 };
 
 TEST_F(LayerTreeHostImplTestScrollbarOpacity, LinearFade) {
   RunTest(LayerTreeSettings::LINEAR_FADE);
 }
 
 TEST_F(LayerTreeHostImplTestScrollbarOpacity, Thinning) {
   RunTest(LayerTreeSettings::THINNING);
 }
 
+TEST_F(LayerTreeHostImplTestScrollbarOpacity, NoAnimator) {
+  RunTest(LayerTreeSettings::NO_ANIMATOR);
+}
+
 TEST_F(LayerTreeHostImplTest, ScrollbarInnerLargerThanOuter) {
   LayerTreeSettings settings = DefaultSettings();
   CreateHostImpl(settings, CreateOutputSurface());
 
   gfx::Size inner_viewport_size(315, 200);
   gfx::Size outer_viewport_size(300, 200);
   gfx::Size content_size(1000, 1000);
 
   const int horiz_id = 11;
   const int child_clip_id = 14;
@@ skipping 7837 matching lines @@
   EXPECT_TRUE(host_impl_->use_gpu_rasterization());
 
   // Re-initialize with a software output surface.
   output_surface_ = FakeOutputSurface::CreateDelegatingSoftware();
   host_impl_->InitializeRenderer(output_surface_.get());
   EXPECT_FALSE(host_impl_->use_gpu_rasterization());
 }
 
 }  // namespace
 }  // namespace cc