Replace layer id with Element id for tracking scrollbar animation controllers

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 1023 matching lines @@
   scroll->SetBounds(scroll_content_size);
   scroll->SetScrollClipLayer(clip->id());
   scroll->SetElementId(LayerIdToElementIdForTesting(scroll->id()));
   scroll->SetDrawsContent(true);
 
   std::unique_ptr<SolidColorScrollbarLayerImpl> scrollbar =
       SolidColorScrollbarLayerImpl::Create(layer_tree_impl, 4, VERTICAL, 10, 0,
                                            false, true);
   scrollbar->SetBounds(scrollbar_size);
   scrollbar->SetPosition(gfx::PointF(345, 0));
-  scrollbar->SetScrollLayerId(scroll->id());
+  scrollbar->SetScrollInfo(scroll->id(), scroll->element_id());
   scrollbar->SetDrawsContent(true);
   scrollbar->test_properties()->opacity = 1.f;
 
   std::unique_ptr<LayerImpl> squash1 = LayerImpl::Create(layer_tree_impl, 5);
   squash1->SetBounds(gfx::Size(140, 300));
   squash1->SetPosition(gfx::PointF(220, 0));
   squash1->SetDrawsContent(true);
 
   std::unique_ptr<LayerImpl> squash2 = LayerImpl::Create(layer_tree_impl, 6);
   squash2->SetBounds(gfx::Size(140, 300));
@@ skipping 51 matching lines @@
   scroll->SetBounds(scroll_content_size);
   scroll->SetScrollClipLayer(clip->id());
   scroll->SetElementId(LayerIdToElementIdForTesting(scroll->id()));
   scroll->SetDrawsContent(true);
 
   std::unique_ptr<SolidColorScrollbarLayerImpl> drawn_scrollbar =
       SolidColorScrollbarLayerImpl::Create(layer_tree_impl, 4, VERTICAL, 10, 0,
                                            false, true);
   drawn_scrollbar->SetBounds(scrollbar_size);
   drawn_scrollbar->SetPosition(gfx::PointF(345, 0));
-  drawn_scrollbar->SetScrollLayerId(scroll->id());
+  drawn_scrollbar->SetScrollInfo(scroll->id(), scroll->element_id());
   drawn_scrollbar->SetDrawsContent(true);
   drawn_scrollbar->test_properties()->opacity = 1.f;
 
   std::unique_ptr<LayerImpl> squash = LayerImpl::Create(layer_tree_impl, 5);
   squash->SetBounds(gfx::Size(140, 300));
   squash->SetPosition(gfx::PointF(220, 0));
   squash->SetDrawsContent(true);
 
   scroll->test_properties()->AddChild(std::move(drawn_scrollbar));
   scroll->test_properties()->AddChild(std::move(squash));
@@ skipping 1722 matching lines @@
         gfx::Size(content_size.width() / 2, content_size.height() / 2));
 
     std::unique_ptr<SolidColorScrollbarLayerImpl> scrollbar =
         SolidColorScrollbarLayerImpl::Create(host_impl_->active_tree(), 400,
                                              VERTICAL, 10, 0, false, true);
     scrollbar->test_properties()->opacity = 0.f;
     EXPECT_FLOAT_EQ(0.f, scrollbar->test_properties()->opacity);
 
     LayerImpl* scroll = host_impl_->active_tree()->OuterViewportScrollLayer();
     LayerImpl* root = host_impl_->active_tree()->InnerViewportContainerLayer();
-    scrollbar->SetScrollLayerId(scroll->id());
+    scrollbar->SetScrollInfo(scroll->id(), scroll->element_id());
     root->test_properties()->AddChild(std::move(scrollbar));
     host_impl_->active_tree()->BuildPropertyTreesForTesting();
     host_impl_->active_tree()->DidBecomeActive();
     DrawFrame();
 
-    // SetScrollLayerId will initialize the scrollbar which will cause it to
+    // SetScrollInfo will initialize the scrollbar which will cause it to
     // show and request a redraw.
     did_request_redraw_ = false;
   }
 
   void RunTest(LayerTreeSettings::ScrollbarAnimator animator) {
     LayerTreeSettings settings = DefaultSettings();
     settings.scrollbar_animator = animator;
     settings.scrollbar_show_delay = base::TimeDelta::FromMilliseconds(20);
     settings.scrollbar_fade_out_delay = base::TimeDelta::FromMilliseconds(20);
     settings.scrollbar_fade_out_resize_delay =
@@ skipping 230 matching lines @@
     CreateHostImpl(settings, CreateCompositorFrameSink());
     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());
+    scrollbar->SetScrollInfo(scroll->id(), scroll->element_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);
 
     if (expecting_animations) {
-      host_impl_->ScrollbarAnimationControllerForId(scroll->id())
+      host_impl_->ScrollbarAnimationControllerForElementId(scroll->element_id())
           ->DidMouseMoveNear(VERTICAL, 0);
     } else {
-      EXPECT_EQ(nullptr,
-                host_impl_->ScrollbarAnimationControllerForId(scroll->id()));
+      EXPECT_EQ(nullptr, host_impl_->ScrollbarAnimationControllerForElementId(
+                             scroll->element_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;
@@ skipping 54 matching lines @@
   CreateHostImpl(settings, CreateCompositorFrameSink());
   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());
+  scrollbar->SetScrollInfo(scroll->id(), scroll->element_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();
 
   ScrollbarAnimationController* scrollbar_controller =
-      host_impl_->ScrollbarAnimationControllerForId(scroll->id());
+      host_impl_->ScrollbarAnimationControllerForElementId(
+          scroll->element_id());
 
   // Scrollbars will flash shown but we should have a fade out animation
   // queued. Run it and fade out the scrollbars.
   {
     ASSERT_FALSE(animation_task_.Equals(base::Closure()));
     ASSERT_FALSE(animation_task_.IsCancelled());
     animation_task_.Run();
 
     base::TimeTicks fake_now = base::TimeTicks::Now();
     scrollbar_controller->Animate(fake_now);
@@ skipping 47 matching lines @@
   std::unique_ptr<SolidColorScrollbarLayerImpl> horiz_scrollbar =
       SolidColorScrollbarLayerImpl::Create(host_impl_->active_tree(), horiz_id,
                                            HORIZONTAL, 5, 5, true, true);
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl_->active_tree(), child_scroll_id);
   child->SetBounds(content_size);
   std::unique_ptr<LayerImpl> child_clip =
       LayerImpl::Create(host_impl_->active_tree(), child_clip_id);
   child->SetBounds(inner_viewport_size);
 
-  horiz_scrollbar->SetScrollLayerId(root_scroll->id());
+  horiz_scrollbar->SetScrollInfo(root_scroll->id(), root_scroll->element_id());
 
   EXPECT_EQ(300, horiz_scrollbar->clip_layer_length());
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollbarRegistration) {
   LayerTreeSettings settings = DefaultSettings();
   settings.scrollbar_animator = LayerTreeSettings::ANDROID_OVERLAY;
   settings.scrollbar_show_delay = base::TimeDelta::FromMilliseconds(20);
   settings.scrollbar_fade_out_delay = base::TimeDelta::FromMilliseconds(20);
   settings.scrollbar_fade_out_duration = base::TimeDelta::FromMilliseconds(20);
@@ skipping 30 matching lines @@
       LayerImpl::Create(host_impl_->active_tree(), child_scroll_id);
   child->SetBounds(content_size);
   std::unique_ptr<LayerImpl> child_clip =
       LayerImpl::Create(host_impl_->active_tree(), child_clip_id);
   child->SetBounds(viewport_size);
   LayerImpl* child_ptr = child.get();
   LayerImpl* child_clip_ptr = child_clip.get();
 
   // Check scrollbar registration on the viewport layers.
   EXPECT_EQ(0ul, host_impl_->ScrollbarsFor(root_scroll->id()).size());
-  EXPECT_EQ(nullptr,
-            host_impl_->ScrollbarAnimationControllerForId(root_scroll->id()));
-  vert_1_scrollbar->SetScrollLayerId(root_scroll->id());
+  EXPECT_EQ(nullptr, host_impl_->ScrollbarAnimationControllerForElementId(
+                         root_scroll->element_id()));
+  vert_1_scrollbar->SetScrollInfo(root_scroll->id(), root_scroll->element_id());
   EXPECT_EQ(1ul, host_impl_->ScrollbarsFor(root_scroll->id()).size());
-  EXPECT_TRUE(host_impl_->ScrollbarAnimationControllerForId(root_scroll->id()));
-  horiz_1_scrollbar->SetScrollLayerId(root_scroll->id());
+  EXPECT_TRUE(host_impl_->ScrollbarAnimationControllerForElementId(
+      root_scroll->element_id()));
+  horiz_1_scrollbar->SetScrollInfo(root_scroll->id(),
+                                   root_scroll->element_id());
   EXPECT_EQ(2ul, host_impl_->ScrollbarsFor(root_scroll->id()).size());
-  EXPECT_TRUE(host_impl_->ScrollbarAnimationControllerForId(root_scroll->id()));
+  EXPECT_TRUE(host_impl_->ScrollbarAnimationControllerForElementId(
+      root_scroll->element_id()));
 
   // Changing one of the viewport layers should result in a scrollbar animation
   // update.
   animation_task_ = base::Closure();
   host_impl_->active_tree()->InnerViewportContainerLayer()->SetBoundsDelta(
       gfx::Vector2dF(10, 10));
   EXPECT_FALSE(animation_task_.Equals(base::Closure()));
   animation_task_ = base::Closure();
   host_impl_->active_tree()->OuterViewportScrollLayer()->SetCurrentScrollOffset(
       gfx::ScrollOffset(10, 10));
   EXPECT_FALSE(animation_task_.Equals(base::Closure()));
   animation_task_ = base::Closure();
   host_impl_->active_tree()->InnerViewportScrollLayer()->SetCurrentScrollOffset(
       gfx::ScrollOffset(10, 10));
   EXPECT_FALSE(animation_task_.Equals(base::Closure()));
   animation_task_ = base::Closure();
 
   // Check scrollbar registration on a sublayer.
   child->SetScrollClipLayer(child_clip->id());
   child->SetElementId(LayerIdToElementIdForTesting(child->id()));
+  ElementId child_scroll_element_id = child->element_id();
   child_clip->test_properties()->AddChild(std::move(child));
   root_scroll->test_properties()->AddChild(std::move(child_clip));
   EXPECT_EQ(0ul, host_impl_->ScrollbarsFor(child_scroll_id).size());
-  EXPECT_EQ(nullptr,
-            host_impl_->ScrollbarAnimationControllerForId(child_scroll_id));
-  vert_2_scrollbar->SetScrollLayerId(child_scroll_id);
+  EXPECT_EQ(nullptr, host_impl_->ScrollbarAnimationControllerForElementId(
+                         child_scroll_element_id));
+  vert_2_scrollbar->SetScrollInfo(child_scroll_id, child_scroll_element_id);
   EXPECT_EQ(1ul, host_impl_->ScrollbarsFor(child_scroll_id).size());
-  EXPECT_TRUE(host_impl_->ScrollbarAnimationControllerForId(child_scroll_id));
-  horiz_2_scrollbar->SetScrollLayerId(child_scroll_id);
+  EXPECT_TRUE(host_impl_->ScrollbarAnimationControllerForElementId(
+      child_scroll_element_id));
+  horiz_2_scrollbar->SetScrollInfo(child_scroll_id, child_scroll_element_id);
   EXPECT_EQ(2ul, host_impl_->ScrollbarsFor(child_scroll_id).size());
-  EXPECT_TRUE(host_impl_->ScrollbarAnimationControllerForId(child_scroll_id));
+  EXPECT_TRUE(host_impl_->ScrollbarAnimationControllerForElementId(
+      child_scroll_element_id));
 
   // Changing one of the child layers should result in a scrollbar animation
   // update.
   animation_task_ = base::Closure();
   child_clip_ptr->SetBounds(gfx::Size(200, 200));
   EXPECT_FALSE(animation_task_.Equals(base::Closure()));
   animation_task_ = base::Closure();
   child_ptr->SetCurrentScrollOffset(gfx::ScrollOffset(10, 10));
   EXPECT_FALSE(animation_task_.Equals(base::Closure()));
   animation_task_ = base::Closure();
 
   // Check scrollbar unregistration.
   vert_1_scrollbar.reset();
   EXPECT_EQ(1ul, host_impl_->ScrollbarsFor(root_scroll->id()).size());
-  EXPECT_TRUE(host_impl_->ScrollbarAnimationControllerForId(root_scroll->id()));
+  EXPECT_TRUE(host_impl_->ScrollbarAnimationControllerForElementId(
+      root_scroll->element_id()));
   horiz_1_scrollbar.reset();
   EXPECT_EQ(0ul, host_impl_->ScrollbarsFor(root_scroll->id()).size());
-  EXPECT_EQ(nullptr,
-            host_impl_->ScrollbarAnimationControllerForId(root_scroll->id()));
+  EXPECT_EQ(nullptr, host_impl_->ScrollbarAnimationControllerForElementId(
+                         root_scroll->element_id()));
 
   EXPECT_EQ(2ul, host_impl_->ScrollbarsFor(child_scroll_id).size());
   vert_2_scrollbar.reset();
   EXPECT_EQ(1ul, host_impl_->ScrollbarsFor(child_scroll_id).size());
-  EXPECT_TRUE(host_impl_->ScrollbarAnimationControllerForId(child_scroll_id));
+  EXPECT_TRUE(host_impl_->ScrollbarAnimationControllerForElementId(
+      child_scroll_element_id));
   horiz_2_scrollbar.reset();
   EXPECT_EQ(0ul, host_impl_->ScrollbarsFor(child_scroll_id).size());
-  EXPECT_EQ(nullptr,
-            host_impl_->ScrollbarAnimationControllerForId(root_scroll->id()));
+  EXPECT_EQ(nullptr, host_impl_->ScrollbarAnimationControllerForElementId(
+                         root_scroll->element_id()));
 
   // Changing scroll offset should no longer trigger any animation.
   host_impl_->active_tree()->InnerViewportScrollLayer()->SetCurrentScrollOffset(
       gfx::ScrollOffset(20, 20));
   EXPECT_TRUE(animation_task_.Equals(base::Closure()));
   child_ptr->SetCurrentScrollOffset(gfx::ScrollOffset(20, 20));
   EXPECT_TRUE(animation_task_.Equals(base::Closure()));
 }
 
 void LayerTreeHostImplTest::SetupMouseMoveAtWithDeviceScale(
@@ skipping 16 matching lines @@
 
   CreateScrollAndContentsLayers(host_impl_->active_tree(), content_size);
   host_impl_->active_tree()->InnerViewportContainerLayer()->SetBounds(
       viewport_size);
   LayerImpl* root_scroll =
       host_impl_->active_tree()->OuterViewportScrollLayer();
   // The scrollbar is on the left side.
   std::unique_ptr<SolidColorScrollbarLayerImpl> scrollbar =
       SolidColorScrollbarLayerImpl::Create(host_impl_->active_tree(), 6,
                                            VERTICAL, 5, 5, true, true);
-  scrollbar->SetScrollLayerId(root_scroll->id());
+  scrollbar->SetScrollInfo(root_scroll->id(), root_scroll->element_id());
   scrollbar->SetDrawsContent(true);
   scrollbar->SetBounds(scrollbar_size);
   scrollbar->SetTouchEventHandlerRegion(gfx::Rect(scrollbar_size));
   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);
 
   ScrollbarAnimationController* scrollbar_animation_controller =
-      host_impl_->ScrollbarAnimationControllerForId(root_scroll->id());
+      host_impl_->ScrollbarAnimationControllerForElementId(
+          root_scroll->element_id());
 
   const float kMouseDistanceToTriggerAnimation =
       SingleScrollbarAnimationControllerThinning::
           kDefaultMouseMoveDistanceToTriggerAnimation;
 
   host_impl_->MouseMoveAt(
       gfx::Point(15 + kMouseDistanceToTriggerAnimation * 2, 1));
   EXPECT_FALSE(scrollbar_animation_controller->MouseIsNearScrollbar(VERTICAL));
 
   host_impl_->MouseMoveAt(
@@ skipping 8603 matching lines @@
   if (main_thread_scrolling) {
     root_scroll->set_main_thread_scrolling_reasons(
         MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
   }
 
   // scrollbar_1 on root scroll.
   std::unique_ptr<SolidColorScrollbarLayerImpl> scrollbar_1 =
       SolidColorScrollbarLayerImpl::Create(host_impl_->active_tree(),
                                            scrollbar_1_id, VERTICAL, 5, 5, true,
                                            true);
-  scrollbar_1->SetScrollLayerId(root_scroll->id());
+  scrollbar_1->SetScrollInfo(root_scroll->id(), root_scroll->element_id());
   scrollbar_1->SetDrawsContent(true);
   scrollbar_1->SetBounds(scrollbar_size_1);
   scrollbar_1->SetTouchEventHandlerRegion(gfx::Rect(scrollbar_size_1));
   host_impl_->active_tree()
       ->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);
 
   ScrollbarAnimationController* scrollbar_1_animation_controller =
-      host_impl_->ScrollbarAnimationControllerForId(root_scroll->id());
+      host_impl_->ScrollbarAnimationControllerForElementId(
+          root_scroll->element_id());
   EXPECT_TRUE(scrollbar_1_animation_controller);
 
   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(15 + kMouseDistanceToTriggerAnimation, 150));
@@ skipping 28 matching lines @@
                                            true);
   std::unique_ptr<LayerImpl> child_clip =
       LayerImpl::Create(host_impl_->active_tree(), child_clip_id);
   std::unique_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl_->active_tree(), child_scroll_id);
   child->SetPosition(gfx::PointF(50, 50));
   child->SetBounds(child_layer_size);
   child->SetDrawsContent(true);
   child->SetScrollClipLayer(child_clip_id);
   child->SetElementId(LayerIdToElementIdForTesting(child->id()));
+  ElementId child_element_id = child->element_id();
 
   if (main_thread_scrolling) {
     child->set_main_thread_scrolling_reasons(
         MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
   }
 
-  scrollbar_2->SetScrollLayerId(child_scroll_id);
+  scrollbar_2->SetScrollInfo(child_scroll_id, child_element_id);
   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();
 
   ScrollbarAnimationController* scrollbar_2_animation_controller =
-      host_impl_->ScrollbarAnimationControllerForId(child_scroll_id);
+      host_impl_->ScrollbarAnimationControllerForElementId(child_element_id);
   EXPECT_TRUE(scrollbar_2_animation_controller);
 
   // 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->MouseIsNearScrollbar(VERTICAL));
   EXPECT_FALSE(
       scrollbar_1_animation_controller->MouseIsOverScrollbar(VERTICAL));
   EXPECT_TRUE(scrollbar_2_animation_controller->MouseIsNearScrollbar(VERTICAL));
@@ skipping 40 matching lines @@
   animation_task_ = base::Closure();
 
   host_impl_->MouseDown();
   host_impl_->MouseUp();
   EXPECT_TRUE(animation_task_.Equals(base::Closure()));
 
   // Near scrollbar_1, then mouse down and unregister
   // scrollbar_2_animation_controller, then mouse up should not cause crash.
   host_impl_->MouseMoveAt(gfx::Point(40, 150));
   host_impl_->MouseDown();
-  host_impl_->UnregisterScrollbarAnimationController(root_scroll->id());
+  host_impl_->UnregisterScrollbarAnimationController(root_scroll->element_id());
   host_impl_->MouseUp();
 }
 
 TEST_F(LayerTreeHostImplTest,
-       LayerTreeHostImplTestScrollbarStatesInMainThreadScorlling) {
+       LayerTreeHostImplTestScrollbarStatesInMainThreadScrolling) {
   SetupMouseMoveAtTestScrollbarStates(true);
 }
 
 TEST_F(LayerTreeHostImplTest,
-       LayerTreeHostImplTestScrollbarStatesInNotMainThreadScorlling) {
+       LayerTreeHostImplTestScrollbarStatesInNotMainThreadScrolling) {
   SetupMouseMoveAtTestScrollbarStates(false);
 }
 
 TEST_F(LayerTreeHostImplTest, CheckerImagingTileInvalidation) {
   LayerTreeSettings settings = DefaultSettings();
   settings.enable_checker_imaging = true;
   settings.default_tile_size = gfx::Size(256, 256);
   settings.max_untiled_layer_size = gfx::Size(256, 256);
   CreateHostImpl(settings, CreateCompositorFrameSink());
   gfx::Size layer_size = gfx::Size(750, 750);
@@ skipping 61 matching lines @@
     else
       EXPECT_FALSE(tile->HasRasterTask());
   }
   Region expected_invalidation(
       raster_source->GetRectForImage(checkerable_image->uniqueID()));
   EXPECT_EQ(expected_invalidation, *(root->GetPendingInvalidation()));
 }
 
 }  // namespace
 }  // namespace cc