Merge Compositor's ScrollbarAnimationControllers into single class

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>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/transform_operations.h"
 #include "cc/base/math_util.h"
 #include "cc/input/browser_controls_offset_manager.h"
 #include "cc/input/main_thread_scrolling_reason.h"
 #include "cc/input/page_scale_animation.h"
-#include "cc/input/scrollbar_animation_controller_thinning.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/painted_scrollbar_layer_impl.h"
 #include "cc/layers/render_surface_impl.h"
 #include "cc/layers/solid_color_layer_impl.h"
 #include "cc/layers/solid_color_scrollbar_layer_impl.h"
 #include "cc/layers/texture_layer_impl.h"
 #include "cc/layers/video_layer_impl.h"
 #include "cc/layers/viewport.h"
@@ skipping 2846 matching lines @@
       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, Android) {
+  RunTest(LayerTreeSettings::ANDROID_OVERLAY);
 }
 
-TEST_F(LayerTreeHostImplTestScrollbarAnimation, Thinning) {
-  RunTest(LayerTreeSettings::THINNING);
+TEST_F(LayerTreeHostImplTestScrollbarAnimation, AuraOverlay) {
+  RunTest(LayerTreeSettings::AURA_OVERLAY);
 }
 
 TEST_F(LayerTreeHostImplTestScrollbarAnimation, NoAnimator) {
   RunTest(LayerTreeSettings::NO_ANIMATOR);
 }
 
 class LayerTreeHostImplTestScrollbarOpacity : public LayerTreeHostImplTest {
  protected:
   void RunTest(LayerTreeSettings::ScrollbarAnimator animator) {
     LayerTreeSettings settings = DefaultSettings();
@@ skipping 73 matching lines @@
     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, Android) {
+  RunTest(LayerTreeSettings::ANDROID_OVERLAY);
 }
 
-TEST_F(LayerTreeHostImplTestScrollbarOpacity, Thinning) {
-  RunTest(LayerTreeSettings::THINNING);
+TEST_F(LayerTreeHostImplTestScrollbarOpacity, AuraOverlay) {
+  RunTest(LayerTreeSettings::AURA_OVERLAY);
 }
 
 TEST_F(LayerTreeHostImplTestScrollbarOpacity, NoAnimator) {
   RunTest(LayerTreeSettings::NO_ANIMATOR);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollbarInnerLargerThanOuter) {
   LayerTreeSettings settings = DefaultSettings();
   CreateHostImpl(settings, CreateCompositorFrameSink());
 
@@ skipping 22 matching lines @@
       LayerImpl::Create(host_impl_->active_tree(), child_clip_id);
   child->SetBounds(inner_viewport_size);
 
   horiz_scrollbar->SetScrollLayerId(root_scroll->id());
 
   EXPECT_EQ(300, horiz_scrollbar->clip_layer_length());
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollbarRegistration) {
   LayerTreeSettings settings = DefaultSettings();
-  settings.scrollbar_animator = LayerTreeSettings::LINEAR_FADE;
+  settings.scrollbar_animator = LayerTreeSettings::ANDROID_OVERLAY;
   settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(20);
   settings.scrollbar_fade_duration = base::TimeDelta::FromMilliseconds(20);
   CreateHostImpl(settings, CreateCompositorFrameSink());
 
   gfx::Size viewport_size(300, 200);
   gfx::Size content_size(1000, 1000);
 
   const int vert_1_id = 10;
   const int horiz_1_id = 11;
   const int vert_2_id = 12;
@@ skipping 102 matching lines @@
   EXPECT_TRUE(animation_task_.Equals(base::Closure()));
   child_ptr->SetCurrentScrollOffset(gfx::ScrollOffset(20, 20));
   EXPECT_TRUE(animation_task_.Equals(base::Closure()));
 }
 
 void LayerTreeHostImplTest::SetupMouseMoveAtWithDeviceScale(
     float device_scale_factor) {
   LayerTreeSettings settings = DefaultSettings();
   settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(500);
   settings.scrollbar_fade_duration = base::TimeDelta::FromMilliseconds(300);
-  settings.scrollbar_animator = LayerTreeSettings::THINNING;
+  settings.scrollbar_animator = LayerTreeSettings::AURA_OVERLAY;
 
   gfx::Size viewport_size(300, 200);
   gfx::Size device_viewport_size =
       gfx::ScaleToFlooredSize(viewport_size, device_scale_factor);
   gfx::Size content_size(1000, 1000);
   gfx::Size scrollbar_size(gfx::Size(15, viewport_size.height()));
 
   CreateHostImpl(settings, CreateCompositorFrameSink());
   host_impl_->active_tree()->SetDeviceScaleFactor(device_scale_factor);
   host_impl_->SetViewportSize(device_viewport_size);
@@ skipping 14 matching lines @@
   host_impl_->active_tree()
       ->InnerViewportContainerLayer()
       ->test_properties()
       ->AddChild(std::move(scrollbar));
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   host_impl_->active_tree()->DidBecomeActive();
 
   DrawFrame();
   host_impl_->active_tree()->UpdateDrawProperties(false);
 
-  ScrollbarAnimationControllerThinning* scrollbar_animation_controller =
-      static_cast<ScrollbarAnimationControllerThinning*>(
-          host_impl_->ScrollbarAnimationControllerForId(root_scroll->id()));
-  scrollbar_animation_controller->set_mouse_move_distance_for_test(100.f);
+  ScrollbarAnimationController* scrollbar_animation_controller =
+      host_impl_->ScrollbarAnimationControllerForId(root_scroll->id());
 
-  host_impl_->MouseMoveAt(gfx::Point(200, 1));
+  const float kMouseDistanceToTriggerAnimation =
+      SingleScrollbarAnimationControllerThinning::
+          kDefaultMouseMoveDistanceToTriggerAnimation;
+
+  host_impl_->MouseMoveAt(
+      gfx::Point(15 + kMouseDistanceToTriggerAnimation * 2, 1));
   EXPECT_FALSE(
       scrollbar_animation_controller->mouse_is_near_scrollbar(VERTICAL));
 
-  host_impl_->MouseMoveAt(gfx::Point(100, 50));
+  host_impl_->MouseMoveAt(
+      gfx::Point(15 + kMouseDistanceToTriggerAnimation - 1, 50));
   EXPECT_TRUE(
       scrollbar_animation_controller->mouse_is_near_scrollbar(VERTICAL));
 
-  host_impl_->MouseMoveAt(gfx::Point(116, 100));
+  host_impl_->MouseMoveAt(
+      gfx::Point(15 + kMouseDistanceToTriggerAnimation, 100));
   EXPECT_FALSE(
       scrollbar_animation_controller->mouse_is_near_scrollbar(VERTICAL));
 
-  scrollbar_animation_controller->set_mouse_move_distance_for_test(102.f);
-  host_impl_->MouseMoveAt(gfx::Point(116, 100));
-  EXPECT_TRUE(
-      scrollbar_animation_controller->mouse_is_near_scrollbar(VERTICAL));
-
   did_request_redraw_ = false;
   EXPECT_FALSE(
       scrollbar_animation_controller->mouse_is_over_scrollbar(VERTICAL));
   host_impl_->MouseMoveAt(gfx::Point(10, 100));
   EXPECT_TRUE(
       scrollbar_animation_controller->mouse_is_over_scrollbar(VERTICAL));
   host_impl_->MouseMoveAt(gfx::Point(10, 120));
   EXPECT_TRUE(
       scrollbar_animation_controller->mouse_is_over_scrollbar(VERTICAL));
   host_impl_->MouseMoveAt(gfx::Point(150, 120));
@@ skipping 8326 matching lines @@
   compositor_frame_sink_ = FakeCompositorFrameSink::CreateSoftware();
   host_impl_->InitializeRenderer(compositor_frame_sink_.get());
   EXPECT_FALSE(host_impl_->use_gpu_rasterization());
 }
 
 void LayerTreeHostImplTest::SetupMouseMoveAtTestScrollbarStates(
     bool main_thread_scrolling) {
   LayerTreeSettings settings = DefaultSettings();
   settings.scrollbar_fade_delay = base::TimeDelta::FromMilliseconds(500);
   settings.scrollbar_fade_duration = base::TimeDelta::FromMilliseconds(300);
-  settings.scrollbar_animator = LayerTreeSettings::THINNING;
+  settings.scrollbar_animator = LayerTreeSettings::AURA_OVERLAY;
 
   gfx::Size viewport_size(300, 200);
   gfx::Size content_size(1000, 1000);
   gfx::Size child_layer_size(250, 150);
   gfx::Size scrollbar_size_1(gfx::Size(15, viewport_size.height()));
   gfx::Size scrollbar_size_2(gfx::Size(15, child_layer_size.height()));
 
   const int scrollbar_1_id = 10;
   const int scrollbar_2_id = 11;
   const int child_clip_id = 12;
@@ skipping 26 matching lines @@
       ->InnerViewportContainerLayer()
       ->test_properties()
       ->AddChild(std::move(scrollbar_1));
 
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   host_impl_->active_tree()->DidBecomeActive();
 
   DrawFrame();
   host_impl_->active_tree()->UpdateDrawProperties(false);
 
-  ScrollbarAnimationControllerThinning* scrollbar_1_animation_controller =
-      static_cast<ScrollbarAnimationControllerThinning*>(
-          host_impl_->ScrollbarAnimationControllerForId(root_scroll->id()));
+  ScrollbarAnimationController* scrollbar_1_animation_controller =
+      host_impl_->ScrollbarAnimationControllerForId(root_scroll->id());
   EXPECT_TRUE(scrollbar_1_animation_controller);
-  scrollbar_1_animation_controller->set_mouse_move_distance_for_test(40.f);
+
+  const float kMouseDistanceToTriggerAnimation =
+      SingleScrollbarAnimationControllerThinning::
+          kDefaultMouseMoveDistanceToTriggerAnimation;
 
   // Mouse moves close to the scrollbar, goes over the scrollbar, and
   // moves back to where it was.
-  host_impl_->MouseMoveAt(gfx::Point(100, 150));
+  host_impl_->MouseMoveAt(
+      gfx::Point(15 + kMouseDistanceToTriggerAnimation, 150));
   EXPECT_FALSE(
       scrollbar_1_animation_controller->mouse_is_near_scrollbar(VERTICAL));
   EXPECT_FALSE(
       scrollbar_1_animation_controller->mouse_is_over_scrollbar(VERTICAL));
-  host_impl_->MouseMoveAt(gfx::Point(40, 150));
+  host_impl_->MouseMoveAt(
+      gfx::Point(14 + kMouseDistanceToTriggerAnimation, 150));
   EXPECT_TRUE(
       scrollbar_1_animation_controller->mouse_is_near_scrollbar(VERTICAL));
   EXPECT_FALSE(
       scrollbar_1_animation_controller->mouse_is_over_scrollbar(VERTICAL));
   host_impl_->MouseMoveAt(gfx::Point(10, 150));
   EXPECT_TRUE(
       scrollbar_1_animation_controller->mouse_is_near_scrollbar(VERTICAL));
   EXPECT_TRUE(
       scrollbar_1_animation_controller->mouse_is_over_scrollbar(VERTICAL));
-  host_impl_->MouseMoveAt(gfx::Point(40, 150));
+  host_impl_->MouseMoveAt(
+      gfx::Point(14 + kMouseDistanceToTriggerAnimation, 150));
   EXPECT_TRUE(
       scrollbar_1_animation_controller->mouse_is_near_scrollbar(VERTICAL));
   EXPECT_FALSE(
       scrollbar_1_animation_controller->mouse_is_over_scrollbar(VERTICAL));
-  host_impl_->MouseMoveAt(gfx::Point(100, 150));
+  host_impl_->MouseMoveAt(
+      gfx::Point(15 + kMouseDistanceToTriggerAnimation, 150));
   EXPECT_FALSE(
       scrollbar_1_animation_controller->mouse_is_near_scrollbar(VERTICAL));
   EXPECT_FALSE(
       scrollbar_1_animation_controller->mouse_is_over_scrollbar(VERTICAL));
 
   // scrollbar_2 on child.
   std::unique_ptr<SolidColorScrollbarLayerImpl> scrollbar_2 =
       SolidColorScrollbarLayerImpl::Create(host_impl_->active_tree(),
                                            scrollbar_2_id, VERTICAL, 5, 5, true,
                                            true);
@@ skipping 15 matching lines @@
   scrollbar_2->SetDrawsContent(true);
   scrollbar_2->SetBounds(scrollbar_size_2);
 
   child->test_properties()->AddChild(std::move(scrollbar_2));
   child_clip->test_properties()->AddChild(std::move(child));
   root_scroll->test_properties()->AddChild(std::move(child_clip));
 
   host_impl_->active_tree()->BuildPropertyTreesForTesting();
   host_impl_->active_tree()->DidBecomeActive();
 
-  ScrollbarAnimationControllerThinning* scrollbar_2_animation_controller =
-      static_cast<ScrollbarAnimationControllerThinning*>(
-          host_impl_->ScrollbarAnimationControllerForId(child_scroll_id));
+  ScrollbarAnimationController* scrollbar_2_animation_controller =
+      host_impl_->ScrollbarAnimationControllerForId(child_scroll_id);
   EXPECT_TRUE(scrollbar_2_animation_controller);
-  scrollbar_2_animation_controller->set_mouse_move_distance_for_test(40.f);
 
   // Mouse goes over scrollbar_2, moves close to scrollbar_2, moves close to
   // scrollbar_1, goes over scrollbar_1.
   host_impl_->MouseMoveAt(gfx::Point(60, 150));
   EXPECT_FALSE(
       scrollbar_1_animation_controller->mouse_is_near_scrollbar(VERTICAL));
   EXPECT_FALSE(
       scrollbar_1_animation_controller->mouse_is_over_scrollbar(VERTICAL));
   EXPECT_TRUE(
       scrollbar_2_animation_controller->mouse_is_near_scrollbar(VERTICAL));
   EXPECT_TRUE(
       scrollbar_2_animation_controller->mouse_is_over_scrollbar(VERTICAL));
-  host_impl_->MouseMoveAt(gfx::Point(100, 150));
+  host_impl_->MouseMoveAt(
+      gfx::Point(64 + kMouseDistanceToTriggerAnimation, 150));
   EXPECT_FALSE(
       scrollbar_1_animation_controller->mouse_is_near_scrollbar(VERTICAL));
   EXPECT_FALSE(
       scrollbar_1_animation_controller->mouse_is_over_scrollbar(VERTICAL));
   EXPECT_TRUE(
       scrollbar_2_animation_controller->mouse_is_near_scrollbar(VERTICAL));
   EXPECT_FALSE(
       scrollbar_2_animation_controller->mouse_is_over_scrollbar(VERTICAL));
-  host_impl_->MouseMoveAt(gfx::Point(40, 150));
+  host_impl_->MouseMoveAt(
+      gfx::Point(14 + kMouseDistanceToTriggerAnimation, 150));
   EXPECT_TRUE(
       scrollbar_1_animation_controller->mouse_is_near_scrollbar(VERTICAL));
   EXPECT_FALSE(
       scrollbar_1_animation_controller->mouse_is_over_scrollbar(VERTICAL));
   EXPECT_FALSE(
       scrollbar_2_animation_controller->mouse_is_near_scrollbar(VERTICAL));
   EXPECT_FALSE(
       scrollbar_2_animation_controller->mouse_is_over_scrollbar(VERTICAL));
   host_impl_->MouseMoveAt(gfx::Point(10, 150));
   EXPECT_TRUE(
@@ skipping 21 matching lines @@
   SetupMouseMoveAtTestScrollbarStates(true);
 }
 
 TEST_F(LayerTreeHostImplTest,
        LayerTreeHostImplTestScrollbarStatesInNotMainThreadScorlling) {
   SetupMouseMoveAtTestScrollbarStates(false);
 }
 
 }  // namespace
 }  // namespace cc