Hit test on the layer tree rather than the RSLL

cc/trees/layer_tree_host_common_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_common.h"
 
 #include <set>
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/transform_operations.h"
@@ skipping 4122 matching lines @@
       render_surface_layer_list.at(1)->render_surface()->layer_list().size());
   EXPECT_EQ(front_facing_surface->id(),
             render_surface_layer_list.at(1)
                 ->render_surface()->layer_list().at(0)->id());
   EXPECT_EQ(child1->id(),
             render_surface_layer_list.at(1)
                 ->render_surface()->layer_list().at(1)->id());
 }
 
 
-TEST_F(LayerTreeHostCommonTest, HitTestingForEmptyLayerList) {
-  // Hit testing on an empty render_surface_layer_list should return a null
-  // pointer.
-  LayerImplList render_surface_layer_list;
-
-  gfx::Point test_point(0, 0);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(10, 20);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-}
-
 TEST_F(LayerTreeHostCommonTest, HitTestingForSingleLayer) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
 
   gfx::Transform identity_matrix;
   gfx::PointF anchor;
   gfx::PointF position;
@@ skipping 12 matching lines @@
       root.get(), root->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
 
   // Hit testing for a point outside the layer should return a null pointer.
   gfx::Point test_point(101, 101);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  LayerImpl* result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(-1, -1);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Hit testing for a point inside should return the root layer.
   test_point = gfx::Point(1, 1);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 
   test_point = gfx::Point(99, 99);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForSingleLayerAndHud) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
@@ skipping 32 matching lines @@
       root.get(), hud_bounds, &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(2u, root->render_surface()->layer_list().size());
 
   // Hit testing for a point inside HUD, but outside root should return null
   gfx::Point test_point(101, 101);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  LayerImpl* result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(-1, -1);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Hit testing for a point inside should return the root layer, never the HUD
   // layer.
   test_point = gfx::Point(1, 1);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 
   test_point = gfx::Point(99, 99);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForUninvertibleTransform) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
@@ skipping 26 matching lines @@
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
   ASSERT_FALSE(root->screen_space_transform().IsInvertible());
 
   // Hit testing any point should not hit the layer. If the invertible matrix is
   // accidentally ignored and treated like an identity, then the hit testing
   // will incorrectly hit the layer when it shouldn't.
   gfx::Point test_point(1, 1);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  LayerImpl* result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(10, 10);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(10, 30);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(50, 50);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(67, 48);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(99, 99);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(-1, -1);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForSinglePositionedLayer) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
 
@@ skipping 17 matching lines @@
       root.get(), root->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
 
   // Hit testing for a point outside the layer should return a null pointer.
   gfx::Point test_point(49, 49);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  LayerImpl* result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Even though the layer exists at (101, 101), it should not be visible there
   // since the root render surface would clamp it.
   test_point = gfx::Point(101, 101);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Hit testing for a point inside should return the root layer.
   test_point = gfx::Point(51, 51);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 
   test_point = gfx::Point(99, 99);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForSingleRotatedLayer) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
@@ skipping 22 matching lines @@
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
 
   // Hit testing for points outside the layer.
   // These corners would have been inside the un-transformed layer, but they
   // should not hit the correctly transformed layer.
   gfx::Point test_point(99, 99);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  LayerImpl* result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(1, 1);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Hit testing for a point inside should return the root layer.
   test_point = gfx::Point(1, 50);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 
   // Hit testing the corners that would overlap the unclipped layer, but are
   // outside the clipped region.
   test_point = gfx::Point(50, -1);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_FALSE(result_layer);
 
   test_point = gfx::Point(-1, 50);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_FALSE(result_layer);
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForSinglePerspectiveLayer) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
 
@@ skipping 28 matching lines @@
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
 
   // Hit testing for points outside the layer.
   // These corners would have been inside the un-transformed layer, but they
   // should not hit the correctly transformed layer.
   gfx::Point test_point(24, 24);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  LayerImpl* result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(76, 76);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Hit testing for a point inside should return the root layer.
   test_point = gfx::Point(26, 26);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 
   test_point = gfx::Point(74, 74);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForSingleLayerWithScaledContents) {
   // A layer's visible content rect is actually in the layer's content space.
   // The screen space transform converts from the layer's origin space to screen
   // space. This test makes sure that hit testing works correctly accounts for
   // the contents scale.  A contents scale that is not 1 effectively forces a
   // non-identity transform between layer's content space and layer's origin
@@ skipping 50 matching lines @@
   // its layout size is 50x50, positioned at 25x25.
   LayerImpl* test_layer = root->children()[0];
   EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100),
                  test_layer->visible_content_rect());
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
 
   // Hit testing for a point outside the layer should return a null pointer (the
   // root layer does not draw content, so it will not be hit tested either).
   gfx::Point test_point(101, 101);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  LayerImpl* result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(24, 24);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(76, 76);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Hit testing for a point inside should return the test layer.
   test_point = gfx::Point(26, 26);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 
   test_point = gfx::Point(74, 74);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForSimpleClippedLayer) {
   // Test that hit-testing will only work for the visible portion of a layer,
   // and not the entire layer bounds. Here we just test the simple axis-aligned
   // case.
   gfx::Transform identity_matrix;
   gfx::PointF anchor;
@@ skipping 49 matching lines @@
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
   ASSERT_EQ(456, root->render_surface()->layer_list().at(0)->id());
 
   // Hit testing for a point outside the layer should return a null pointer.
   // Despite the child layer being very large, it should be clipped to the root
   // layer's bounds.
   gfx::Point test_point(24, 24);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  LayerImpl* result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Even though the layer exists at (101, 101), it should not be visible there
   // since the clipping_layer would clamp it.
   test_point = gfx::Point(76, 76);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Hit testing for a point inside should return the child layer.
   test_point = gfx::Point(26, 26);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(456, result_layer->id());
 
   test_point = gfx::Point(74, 74);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(456, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForMultiClippedRotatedLayer) {
   // This test checks whether hit testing correctly avoids hit testing with
   // multiple ancestors that clip in non axis-aligned ways. To pass this test,
   // the hit testing algorithm needs to recognize that multiple parent layers
   // may clip the layer, and should not actually hit those clipped areas.
   //
@@ skipping 99 matching lines @@
   ASSERT_EQ(
       1u,
       render_surface_layer_list.at(1)->render_surface()->layer_list().size());
   ASSERT_EQ(
       2468,
       render_surface_layer_list[1]->render_surface()->layer_list().at(0)->id());
 
   // (11, 89) is close to the the bottom left corner within the clip, but it is
   // not inside the layer.
   gfx::Point test_point(11, 89);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  LayerImpl* result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Closer inwards from the bottom left will overlap the layer.
   test_point = gfx::Point(25, 75);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(2468, result_layer->id());
 
   // (4, 50) is inside the unclipped layer, but that corner of the layer should
   // be clipped away by the grandparent and should not get hit. If hit testing
   // blindly uses visible content rect without considering how parent may clip
   // the layer, then hit testing would accidentally think that the point
   // successfully hits the layer.
   test_point = gfx::Point(4, 50);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // (11, 50) is inside the layer and within the clipped area.
   test_point = gfx::Point(11, 50);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(2468, result_layer->id());
 
   // Around the middle, just to the right and up, would have hit the layer
   // except that that area should be clipped away by the parent.
   test_point = gfx::Point(51, 49);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Around the middle, just to the left and down, should successfully hit the
   // layer.
   test_point = gfx::Point(49, 51);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(2468, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForNonClippingIntermediateLayer) {
   // This test checks that hit testing code does not accidentally clip to layer
   // bounds for a layer that actually does not clip.
   gfx::Transform identity_matrix;
   gfx::PointF anchor;
 
@@ skipping 51 matching lines @@
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
   ASSERT_EQ(456, root->render_surface()->layer_list().at(0)->id());
 
   // Hit testing for a point outside the layer should return a null pointer.
   gfx::Point test_point(69, 69);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  LayerImpl* result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(91, 91);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Hit testing for a point inside should return the child layer.
   test_point = gfx::Point(71, 71);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(456, result_layer->id());
 
   test_point = gfx::Point(89, 89);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(456, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForMultipleLayers) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
 
@@ skipping 83 matching lines @@
   RenderSurfaceImpl* root_render_surface = root->render_surface();
   ASSERT_EQ(4u, root_render_surface->layer_list().size());
   ASSERT_EQ(1, root_render_surface->layer_list().at(0)->id());  // root layer
   ASSERT_EQ(2, root_render_surface->layer_list().at(1)->id());  // child1
   ASSERT_EQ(4, root_render_surface->layer_list().at(2)->id());  // grand_child1
   ASSERT_EQ(3, root_render_surface->layer_list().at(3)->id());  // child2
 
   // Nothing overlaps the root_layer at (1, 1), so hit testing there should find
   // the root layer.
   gfx::Point test_point = gfx::Point(1, 1);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  LayerImpl* result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(1, result_layer->id());
 
   // At (15, 15), child1 and root are the only layers. child1 is expected to be
   // on top.
   test_point = gfx::Point(15, 15);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(2, result_layer->id());
 
   // At (51, 20), child1 and child2 overlap. child2 is expected to be on top.
   test_point = gfx::Point(51, 20);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(3, result_layer->id());
 
   // At (80, 51), child2 and grand_child1 overlap. child2 is expected to be on
   // top.
   test_point = gfx::Point(80, 51);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(3, result_layer->id());
 
   // At (51, 51), all layers overlap each other. child2 is expected to be on top
   // of all other layers.
   test_point = gfx::Point(51, 51);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(3, result_layer->id());
 
   // At (20, 51), child1 and grand_child1 overlap. grand_child1 is expected to
   // be on top.
   test_point = gfx::Point(20, 51);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(4, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForMultipleLayerLists) {
   //
   // The geometry is set up similarly to the previous case, but
   // all layers are forced to be render surfaces now.
   //
   FakeImplProxy proxy;
@@ skipping 97 matching lines @@
   ASSERT_EQ(1u, child2->render_surface()->layer_list().size());
   ASSERT_EQ(1u, grand_child1->render_surface()->layer_list().size());
   ASSERT_EQ(1, render_surface_layer_list.at(0)->id());  // root layer
   ASSERT_EQ(2, render_surface_layer_list[1]->id());  // child1
   ASSERT_EQ(4, render_surface_layer_list.at(2)->id());  // grand_child1
   ASSERT_EQ(3, render_surface_layer_list[3]->id());  // child2
 
   // Nothing overlaps the root_layer at (1, 1), so hit testing there should find
   // the root layer.
   gfx::Point test_point = gfx::Point(1, 1);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  LayerImpl* result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(1, result_layer->id());
 
   // At (15, 15), child1 and root are the only layers. child1 is expected to be
   // on top.
   test_point = gfx::Point(15, 15);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(2, result_layer->id());
 
   // At (51, 20), child1 and child2 overlap. child2 is expected to be on top.
   test_point = gfx::Point(51, 20);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(3, result_layer->id());
 
   // At (80, 51), child2 and grand_child1 overlap. child2 is expected to be on
   // top.
   test_point = gfx::Point(80, 51);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(3, result_layer->id());
 
   // At (51, 51), all layers overlap each other. child2 is expected to be on top
   // of all other layers.
   test_point = gfx::Point(51, 51);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(3, result_layer->id());
 
   // At (20, 51), child1 and grand_child1 overlap. grand_child1 is expected to
   // be on top.
   test_point = gfx::Point(20, 51);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(4, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForEmptyLayers) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
 
   // Layer 1 - root
@@ skipping 80 matching lines @@
   ASSERT_EQ(1u, render_surface_layer_list.size());
   EXPECT_EQ(1, render_surface_layer_list[0]->id());
   ASSERT_EQ(3u, root->render_surface()->layer_list().size());
   EXPECT_EQ(1, root->render_surface()->layer_list().at(0)->id());
   EXPECT_EQ(3, root->render_surface()->layer_list().at(1)->id());
   EXPECT_EQ(4, root->render_surface()->layer_list().at(2)->id());
 
   // Hit testing for a point inside the empty no-handlers layer should return
   // the root layer.
   gfx::Point test_point = gfx::Point(15, 15);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
+  LayerImpl* result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(1, result_layer->id());
 
   // Hit testing for a point inside the touch handler layer should return it.
   test_point = gfx::Point(15, 75);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-          test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(3, result_layer->id());
 
   // Hit testing for a point inside the mousewheel layer should return it.
   test_point = gfx::Point(75, 75);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-          test_point, render_surface_layer_list);
+  result_layer =
+      LayerTreeHostCommon::FindLayerThatIsHitByPoint(test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(4, result_layer->id());
 }
 
-TEST_F(LayerTreeHostCommonTest,
-       HitCheckingTouchHandlerRegionsForEmptyLayerList) {
-  // Hit checking on an empty render_surface_layer_list should return a null
-  // pointer.
-  LayerImplList render_surface_layer_list;
-
-  gfx::Point test_point(0, 0);
-  LayerImpl* result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(10, 20);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-}
-
 TEST_F(LayerTreeHostCommonTest, HitCheckingTouchHandlerRegionsForSingleLayer) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
 
   gfx::Transform identity_matrix;
   Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
   gfx::PointF anchor;
@@ skipping 16 matching lines @@
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
 
   // Hit checking for any point should return a null pointer for a layer without
   // any touch event handler regions.
   gfx::Point test_point(11, 11);
   LayerImpl* result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   root->SetTouchEventHandlerRegion(touch_handler_region);
   // Hit checking for a point outside the layer should return a null pointer.
   test_point = gfx::Point(101, 101);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(-1, -1);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Hit checking for a point inside the layer, but outside the touch handler
   // region should return a null pointer.
   test_point = gfx::Point(1, 1);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(99, 99);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Hit checking for a point inside the touch event handler region should
   // return the root layer.
   test_point = gfx::Point(11, 11);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 
   test_point = gfx::Point(59, 59);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest,
      HitCheckingTouchHandlerRegionsForUninvertibleTransform) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root =
@@ skipping 32 matching lines @@
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
   ASSERT_FALSE(root->screen_space_transform().IsInvertible());
 
   // Hit checking any point should not hit the touch handler region on the
   // layer. If the invertible matrix is accidentally ignored and treated like an
   // identity, then the hit testing will incorrectly hit the layer when it
   // shouldn't.
   gfx::Point test_point(1, 1);
   LayerImpl* result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(10, 10);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(10, 30);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(50, 50);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(67, 48);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(99, 99);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(-1, -1);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 }
 
 TEST_F(LayerTreeHostCommonTest,
      HitCheckingTouchHandlerRegionsForSinglePositionedLayer) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
@@ skipping 22 matching lines @@
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
 
   // Hit checking for a point outside the layer should return a null pointer.
   gfx::Point test_point(49, 49);
   LayerImpl* result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Even though the layer has a touch handler region containing (101, 101), it
   // should not be visible there since the root render surface would clamp it.
   test_point = gfx::Point(101, 101);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Hit checking for a point inside the layer, but outside the touch handler
   // region should return a null pointer.
   test_point = gfx::Point(51, 51);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Hit checking for a point inside the touch event handler region should
   // return the root layer.
   test_point = gfx::Point(61, 61);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 
   test_point = gfx::Point(99, 99);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest,
      HitCheckingTouchHandlerRegionsForSingleLayerWithScaledContents) {
   // A layer's visible content rect is actually in the layer's content space.
   // The screen space transform converts from the layer's origin space to screen
   // space. This test makes sure that hit testing works correctly accounts for
   // the contents scale.  A contents scale that is not 1 effectively forces a
@@ skipping 54 matching lines @@
   LayerImpl* test_layer = root->children()[0];
   EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), test_layer->visible_content_rect());
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
 
   // Hit checking for a point outside the layer should return a null pointer
   // (the root layer does not draw content, so it will not be tested either).
   gfx::Point test_point(76, 76);
   LayerImpl* result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Hit checking for a point inside the layer, but outside the touch handler
   // region should return a null pointer.
   test_point = gfx::Point(26, 26);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(34, 34);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(65, 65);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(74, 74);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Hit checking for a point inside the touch event handler region should
   // return the root layer.
   test_point = gfx::Point(35, 35);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 
   test_point = gfx::Point(64, 64);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest,
      HitCheckingTouchHandlerRegionsForSingleLayerWithDeviceScale) {
   // The layer's device_scale_factor and page_scale_factor should scale the
   // content rect and we should be able to hit the touch handler region by
   // scaling the points accordingly.
   FakeImplProxy proxy;
@@ skipping 55 matching lines @@
   EXPECT_RECT_EQ(gfx::Rect(test_layer->content_bounds()),
                  test_layer->visible_content_rect());
 
   // Hit checking for a point outside the layer should return a null pointer
   // (the root layer does not draw content, so it will not be tested either).
   gfx::PointF test_point(76.f, 76.f);
   test_point =
       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
   LayerImpl* result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Hit checking for a point inside the layer, but outside the touch handler
   // region should return a null pointer.
   test_point = gfx::Point(26, 26);
   test_point =
       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(34, 34);
   test_point =
       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(65, 65);
   test_point =
       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(74, 74);
   test_point =
       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Hit checking for a point inside the touch event handler region should
   // return the root layer.
   test_point = gfx::Point(35, 35);
   test_point =
       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 
   test_point = gfx::Point(64, 64);
   test_point =
       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest,
      HitCheckingTouchHandlerRegionsForSimpleClippedLayer) {
   // Test that hit-checking will only work for the visible portion of a layer,
   // and not the entire layer bounds. Here we just test the simple axis-aligned
   // case.
   gfx::Transform identity_matrix;
@@ skipping 54 matching lines @@
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
   ASSERT_EQ(456, root->render_surface()->layer_list().at(0)->id());
 
   // Hit checking for a point outside the layer should return a null pointer.
   // Despite the child layer being very large, it should be clipped to the root
   // layer's bounds.
   gfx::Point test_point(24, 24);
   LayerImpl* result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Hit checking for a point inside the layer, but outside the touch handler
   // region should return a null pointer.
   test_point = gfx::Point(35, 35);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   test_point = gfx::Point(74, 74);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 
   // Hit checking for a point inside the touch event handler region should
   // return the root layer.
   test_point = gfx::Point(25, 25);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(456, result_layer->id());
 
   test_point = gfx::Point(34, 34);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(456, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        HitCheckingTouchHandlerOverlappingRegions) {
   gfx::Transform identity_matrix;
   gfx::PointF anchor;
 
   FakeImplProxy proxy;
@@ skipping 52 matching lines @@
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(2u, root->render_surface()->layer_list().size());
   ASSERT_EQ(123, root->render_surface()->layer_list().at(0)->id());
   ASSERT_EQ(1234, root->render_surface()->layer_list().at(1)->id());
 
   gfx::Point test_point(35, 35);
   LayerImpl* result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
 
   // We should have passed through the no-touch layer and found the layer
   // behind it.
   EXPECT_TRUE(result_layer);
 
   host_impl.active_tree()->LayerById(1234)->SetContentsOpaque(true);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
 
   // Even with an opaque layer in the middle, we should still find the layer
   // with
   // the touch handler behind it (since we can't assume that opaque layers are
   // opaque to hit testing).
   EXPECT_TRUE(result_layer);
 
   test_point = gfx::Point(35, 15);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(123, result_layer->id());
 
   test_point = gfx::Point(35, 65);
   result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
+          test_point, root.get());
   EXPECT_FALSE(result_layer);
 }
 
 class NoScaleContentLayer : public ContentLayer {
  public:
   static scoped_refptr<NoScaleContentLayer> Create(ContentLayerClient* client) {
     return make_scoped_refptr(new NoScaleContentLayer(client));
   }
 
   virtual void CalculateContentsScale(float ideal_contents_scale,
@@ skipping 4018 matching lines @@
 
   // |grand_parent| has a transform that's neither a translation nor a scale.
   EXPECT_EQ(0.f, grand_parent->last_maximum_animation_contents_scale());
   EXPECT_EQ(0.f, parent_raw->last_maximum_animation_contents_scale());
   EXPECT_EQ(0.f, child_raw->last_maximum_animation_contents_scale());
   EXPECT_EQ(0.f, grand_child_raw->last_maximum_animation_contents_scale());
 }
 
 }  // namespace
 }  // namespace cc