Hit test on the layer tree rather than the RSLL

cc/trees/layer_tree_impl_unittest.cc

Index: cc/trees/layer_tree_impl_unittest.cc
diff --git a/cc/trees/layer_tree_impl_unittest.cc b/cc/trees/layer_tree_impl_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b27a06e8d6f11527d6f2768451d059121fa98cca
--- /dev/null
+++ b/cc/trees/layer_tree_impl_unittest.cc
@@ -0,0 +1,1940 @@
+// Copyright 2014 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_impl.h"
+
+#include "cc/layers/heads_up_display_layer_impl.h"
+#include "cc/layers/layer.h"
+#include "cc/test/fake_impl_proxy.h"
+#include "cc/test/fake_layer_tree_host_impl.h"
+#include "cc/test/fake_output_surface.h"
+#include "cc/test/geometry_test_utils.h"
+#include "cc/test/layer_tree_host_common_test.h"
+#include "cc/test/test_shared_bitmap_manager.h"
+#include "cc/trees/layer_tree_host_impl.h"
+#include "ui/gfx/size_conversions.h"
+
+namespace cc {
+namespace {
+
+class LayerTreeImplTest : public LayerTreeHostCommonTest {
+ public:
+  LayerTreeImplTest() {
+    LayerTreeSettings settings;
+    settings.layer_transforms_should_scale_layer_contents = true;
+    host_impl_.reset(
+        new FakeLayerTreeHostImpl(settings, &proxy_, &shared_bitmap_manager_));
+    EXPECT_TRUE(host_impl_->InitializeRenderer(
+        FakeOutputSurface::Create3d().PassAs<OutputSurface>()));
+  }
+
+  FakeLayerTreeHostImpl& host_impl() { return *host_impl_; }
+
+  LayerImpl* root_layer() { return host_impl_->active_tree()->root_layer(); }
+
+  const LayerImplList& RenderSurfaceLayerList() const {
+    return host_impl_->active_tree()->RenderSurfaceLayerList();
+  }
+
+ private:
+  TestSharedBitmapManager shared_bitmap_manager_;
+  FakeImplProxy proxy_;
+  scoped_ptr<FakeLayerTreeHostImpl> host_impl_;
+};
+
+TEST_F(LayerTreeImplTest, HitTestingForSingleLayer) {
+  scoped_ptr<LayerImpl> root =
+      LayerImpl::Create(host_impl().active_tree(), 12345);
+
+  gfx::Transform identity_matrix;
+  gfx::PointF anchor;
+  gfx::PointF position;
+  gfx::Size bounds(100, 100);
+  SetLayerPropertiesForTesting(
+      root.get(), identity_matrix, anchor, position, bounds, true, false);
+  root->SetDrawsContent(true);
+
+  host_impl().SetViewportSize(root->bounds());
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Sanity check the scenario we just created.
+  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(1u, root_layer()->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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(-1, -1);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  // Hit testing for a point inside should return the root layer.
+  test_point = gfx::Point(1, 1);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(12345, result_layer->id());
+
+  test_point = gfx::Point(99, 99);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(12345, result_layer->id());
+}
+
+TEST_F(LayerTreeImplTest, HitTestingForSingleLayerAndHud) {
+  scoped_ptr<LayerImpl> root =
+      LayerImpl::Create(host_impl().active_tree(), 12345);
+  scoped_ptr<HeadsUpDisplayLayerImpl> hud =
+      HeadsUpDisplayLayerImpl::Create(host_impl().active_tree(), 11111);
+
+  gfx::Transform identity_matrix;
+  gfx::PointF anchor;
+  gfx::PointF position;
+  gfx::Size bounds(100, 100);
+  SetLayerPropertiesForTesting(
+      root.get(), identity_matrix, anchor, position, bounds, true, false);
+  root->SetDrawsContent(true);
+
+  // Create hud and add it as a child of root.
+  gfx::Size hud_bounds(200, 200);
+  SetLayerPropertiesForTesting(
+      hud.get(), identity_matrix, anchor, position, hud_bounds, true, false);
+  hud->SetDrawsContent(true);
+
+  host_impl().active_tree()->set_hud_layer(hud.get());
+  root->AddChild(hud.PassAs<LayerImpl>());
+
+  host_impl().SetViewportSize(hud_bounds);
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Sanity check the scenario we just created.
+  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(2u, root_layer()->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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(-1, -1);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(12345, result_layer->id());
+
+  test_point = gfx::Point(99, 99);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(12345, result_layer->id());
+}
+
+TEST_F(LayerTreeImplTest, HitTestingForUninvertibleTransform) {
+  scoped_ptr<LayerImpl> root =
+      LayerImpl::Create(host_impl().active_tree(), 12345);
+
+  gfx::Transform uninvertible_transform;
+  uninvertible_transform.matrix().set(0, 0, 0.0);
+  uninvertible_transform.matrix().set(1, 1, 0.0);
+  uninvertible_transform.matrix().set(2, 2, 0.0);
+  uninvertible_transform.matrix().set(3, 3, 0.0);
+  ASSERT_FALSE(uninvertible_transform.IsInvertible());
+
+  gfx::Transform identity_matrix;
+  gfx::PointF anchor;
+  gfx::PointF position;
+  gfx::Size bounds(100, 100);
+  SetLayerPropertiesForTesting(root.get(),
+                               uninvertible_transform,
+                               anchor,
+                               position,
+                               bounds,
+                               true,
+                               false);
+  root->SetDrawsContent(true);
+
+  host_impl().SetViewportSize(root->bounds());
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+  // Sanity check the scenario we just created.
+  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
+  ASSERT_FALSE(root_layer()->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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(10, 10);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(10, 30);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(50, 50);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(67, 48);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(99, 99);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(-1, -1);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+}
+
+TEST_F(LayerTreeImplTest, HitTestingForSinglePositionedLayer) {
+  scoped_ptr<LayerImpl> root =
+      LayerImpl::Create(host_impl().active_tree(), 12345);
+
+  gfx::Transform identity_matrix;
+  gfx::PointF anchor;
+  // this layer is positioned, and hit testing should correctly know where the
+  // layer is located.
+  gfx::PointF position(50.f, 50.f);
+  gfx::Size bounds(100, 100);
+  SetLayerPropertiesForTesting(
+      root.get(), identity_matrix, anchor, position, bounds, true, false);
+  root->SetDrawsContent(true);
+
+  host_impl().SetViewportSize(root->bounds());
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Sanity check the scenario we just created.
+  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(1u, root_layer()->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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  // Hit testing for a point inside should return the root layer.
+  test_point = gfx::Point(51, 51);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(12345, result_layer->id());
+
+  test_point = gfx::Point(99, 99);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(12345, result_layer->id());
+}
+
+TEST_F(LayerTreeImplTest, HitTestingForSingleRotatedLayer) {
+  scoped_ptr<LayerImpl> root =
+      LayerImpl::Create(host_impl().active_tree(), 12345);
+
+  gfx::Transform identity_matrix;
+  gfx::Transform rotation45_degrees_about_center;
+  rotation45_degrees_about_center.Translate(50.0, 50.0);
+  rotation45_degrees_about_center.RotateAboutZAxis(45.0);
+  rotation45_degrees_about_center.Translate(-50.0, -50.0);
+  gfx::PointF anchor;
+  gfx::PointF position;
+  gfx::Size bounds(100, 100);
+  SetLayerPropertiesForTesting(root.get(),
+                               rotation45_degrees_about_center,
+                               anchor,
+                               position,
+                               bounds,
+                               true,
+                               false);
+  root->SetDrawsContent(true);
+
+  host_impl().SetViewportSize(root->bounds());
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Sanity check the scenario we just created.
+  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(1u, root_layer()->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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(1, 1);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  // Hit testing for a point inside should return the root layer.
+  test_point = gfx::Point(1, 50);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_FALSE(result_layer);
+
+  test_point = gfx::Point(-1, 50);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_FALSE(result_layer);
+}
+
+TEST_F(LayerTreeImplTest, HitTestingForSinglePerspectiveLayer) {
+  scoped_ptr<LayerImpl> root =
+      LayerImpl::Create(host_impl().active_tree(), 12345);
+
+  gfx::Transform identity_matrix;
+
+  // perspective_projection_about_center * translation_by_z is designed so that
+  // the 100 x 100 layer becomes 50 x 50, and remains centered at (50, 50).
+  gfx::Transform perspective_projection_about_center;
+  perspective_projection_about_center.Translate(50.0, 50.0);
+  perspective_projection_about_center.ApplyPerspectiveDepth(1.0);
+  perspective_projection_about_center.Translate(-50.0, -50.0);
+  gfx::Transform translation_by_z;
+  translation_by_z.Translate3d(0.0, 0.0, -1.0);
+
+  gfx::PointF anchor;
+  gfx::PointF position;
+  gfx::Size bounds(100, 100);
+  SetLayerPropertiesForTesting(
+      root.get(),
+      perspective_projection_about_center * translation_by_z,
+      anchor,
+      position,
+      bounds,
+      true,
+      false);
+  root->SetDrawsContent(true);
+
+  host_impl().SetViewportSize(root->bounds());
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Sanity check the scenario we just created.
+  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(1u, root_layer()->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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(76, 76);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  // Hit testing for a point inside should return the root layer.
+  test_point = gfx::Point(26, 26);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(12345, result_layer->id());
+
+  test_point = gfx::Point(74, 74);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(12345, result_layer->id());
+}
+
+TEST_F(LayerTreeImplTest, 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
+  // space. The hit testing code must take this into account.
+  //
+  // To test this, the layer is positioned at (25, 25), and is size (50, 50). If
+  // contents scale is ignored, then hit testing will mis-interpret the visible
+  // content rect as being larger than the actual bounds of the layer.
+  //
+  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
+
+  gfx::Transform identity_matrix;
+  gfx::PointF anchor;
+
+  SetLayerPropertiesForTesting(root.get(),
+                               identity_matrix,
+                               anchor,
+                               gfx::PointF(),
+                               gfx::Size(100, 100),
+                               true,
+                               false);
+  {
+    gfx::PointF position(25.f, 25.f);
+    gfx::Size bounds(50, 50);
+    scoped_ptr<LayerImpl> test_layer =
+        LayerImpl::Create(host_impl().active_tree(), 12345);
+    SetLayerPropertiesForTesting(test_layer.get(),
+                                 identity_matrix,
+                                 anchor,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
+
+    // override content bounds and contents scale
+    test_layer->SetContentBounds(gfx::Size(100, 100));
+    test_layer->SetContentsScale(2, 2);
+
+    test_layer->SetDrawsContent(true);
+    root->AddChild(test_layer.Pass());
+  }
+
+  host_impl().SetViewportSize(root->bounds());
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Sanity check the scenario we just created.
+  // The visible content rect for test_layer is actually 100x100, even though
+  // its layout size is 50x50, positioned at 25x25.
+  LayerImpl* test_layer =
+      host_impl().active_tree()->root_layer()->children()[0];
+  EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), test_layer->visible_content_rect());
+  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(1u, root_layer()->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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(24, 24);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(76, 76);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  // Hit testing for a point inside should return the test layer.
+  test_point = gfx::Point(26, 26);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(12345, result_layer->id());
+
+  test_point = gfx::Point(74, 74);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(12345, result_layer->id());
+}
+
+TEST_F(LayerTreeImplTest, 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;
+
+  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
+  SetLayerPropertiesForTesting(root.get(),
+                               identity_matrix,
+                               anchor,
+                               gfx::PointF(),
+                               gfx::Size(100, 100),
+                               true,
+                               false);
+  {
+    scoped_ptr<LayerImpl> clipping_layer =
+        LayerImpl::Create(host_impl().active_tree(), 123);
+    // this layer is positioned, and hit testing should correctly know where the
+    // layer is located.
+    gfx::PointF position(25.f, 25.f);
+    gfx::Size bounds(50, 50);
+    SetLayerPropertiesForTesting(clipping_layer.get(),
+                                 identity_matrix,
+                                 anchor,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
+    clipping_layer->SetMasksToBounds(true);
+
+    scoped_ptr<LayerImpl> child =
+        LayerImpl::Create(host_impl().active_tree(), 456);
+    position = gfx::PointF(-50.f, -50.f);
+    bounds = gfx::Size(300, 300);
+    SetLayerPropertiesForTesting(
+        child.get(), identity_matrix, anchor, position, bounds, true, false);
+    child->SetDrawsContent(true);
+    clipping_layer->AddChild(child.Pass());
+    root->AddChild(clipping_layer.Pass());
+  }
+
+  host_impl().SetViewportSize(root->bounds());
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Sanity check the scenario we just created.
+  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
+  ASSERT_EQ(456, root_layer()->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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  // Hit testing for a point inside should return the child layer.
+  test_point = gfx::Point(26, 26);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(456, result_layer->id());
+
+  test_point = gfx::Point(74, 74);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(456, result_layer->id());
+}
+
+TEST_F(LayerTreeImplTest, 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.
+  //
+  // The child and grand_child layers are both initialized to clip the
+  // rotated_leaf. The child layer is rotated about the top-left corner, so that
+  // the root + child clips combined create a triangle. The rotated_leaf will
+  // only be visible where it overlaps this triangle.
+  //
+  scoped_ptr<LayerImpl> root =
+      LayerImpl::Create(host_impl().active_tree(), 123);
+
+  gfx::Transform identity_matrix;
+  gfx::PointF anchor;
+  gfx::PointF position;
+  gfx::Size bounds(100, 100);
+  SetLayerPropertiesForTesting(
+      root.get(), identity_matrix, anchor, position, bounds, true, false);
+  root->SetMasksToBounds(true);
+  {
+    scoped_ptr<LayerImpl> child =
+        LayerImpl::Create(host_impl().active_tree(), 456);
+    scoped_ptr<LayerImpl> grand_child =
+        LayerImpl::Create(host_impl().active_tree(), 789);
+    scoped_ptr<LayerImpl> rotated_leaf =
+        LayerImpl::Create(host_impl().active_tree(), 2468);
+
+    position = gfx::PointF(10.f, 10.f);
+    bounds = gfx::Size(80, 80);
+    SetLayerPropertiesForTesting(
+        child.get(), identity_matrix, anchor, position, bounds, true, false);
+    child->SetMasksToBounds(true);
+
+    gfx::Transform rotation45_degrees_about_corner;
+    rotation45_degrees_about_corner.RotateAboutZAxis(45.0);
+
+    // remember, positioned with respect to its parent which is already at 10,
+    // 10
+    position = gfx::PointF();
+    bounds =
+        gfx::Size(200, 200);  // to ensure it covers at least sqrt(2) * 100.
+    SetLayerPropertiesForTesting(grand_child.get(),
+                                 rotation45_degrees_about_corner,
+                                 anchor,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
+    grand_child->SetMasksToBounds(true);
+
+    // Rotates about the center of the layer
+    gfx::Transform rotated_leaf_transform;
+    rotated_leaf_transform.Translate(
+        -10.0, -10.0);  // cancel out the grand_parent's position
+    rotated_leaf_transform.RotateAboutZAxis(
+        -45.0);  // cancel out the corner 45-degree rotation of the parent.
+    rotated_leaf_transform.Translate(50.0, 50.0);
+    rotated_leaf_transform.RotateAboutZAxis(45.0);
+    rotated_leaf_transform.Translate(-50.0, -50.0);
+    position = gfx::PointF();
+    bounds = gfx::Size(100, 100);
+    SetLayerPropertiesForTesting(rotated_leaf.get(),
+                                 rotated_leaf_transform,
+                                 anchor,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
+    rotated_leaf->SetDrawsContent(true);
+
+    grand_child->AddChild(rotated_leaf.Pass());
+    child->AddChild(grand_child.Pass());
+    root->AddChild(child.Pass());
+  }
+
+  host_impl().SetViewportSize(root->bounds());
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Sanity check the scenario we just created.
+  // The grand_child is expected to create a render surface because it
+  // MasksToBounds and is not axis aligned.
+  ASSERT_EQ(2u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(
+      1u,
+      RenderSurfaceLayerList().at(0)->render_surface()->layer_list().size());
+  ASSERT_EQ(789,
+            RenderSurfaceLayerList()
+                .at(0)
+                ->render_surface()
+                ->layer_list()
+                .at(0)
+                ->id());  // grand_child's surface.
+  ASSERT_EQ(
+      1u,
+      RenderSurfaceLayerList().at(1)->render_surface()->layer_list().size());
+  ASSERT_EQ(
+      2468,
+      RenderSurfaceLayerList()[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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  // Closer inwards from the bottom left will overlap the layer.
+  test_point = gfx::Point(25, 75);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  // (11, 50) is inside the layer and within the clipped area.
+  test_point = gfx::Point(11, 50);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(2468, result_layer->id());
+}
+
+TEST_F(LayerTreeImplTest, 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;
+
+  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
+  SetLayerPropertiesForTesting(root.get(),
+                               identity_matrix,
+                               anchor,
+                               gfx::PointF(),
+                               gfx::Size(100, 100),
+                               true,
+                               false);
+  {
+    scoped_ptr<LayerImpl> intermediate_layer =
+        LayerImpl::Create(host_impl().active_tree(), 123);
+    // this layer is positioned, and hit testing should correctly know where the
+    // layer is located.
+    gfx::PointF position(10.f, 10.f);
+    gfx::Size bounds(50, 50);
+    SetLayerPropertiesForTesting(intermediate_layer.get(),
+                                 identity_matrix,
+                                 anchor,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
+    // Sanity check the intermediate layer should not clip.
+    ASSERT_FALSE(intermediate_layer->masks_to_bounds());
+    ASSERT_FALSE(intermediate_layer->mask_layer());
+
+    // The child of the intermediate_layer is translated so that it does not
+    // overlap intermediate_layer at all.  If child is incorrectly clipped, we
+    // would not be able to hit it successfully.
+    scoped_ptr<LayerImpl> child =
+        LayerImpl::Create(host_impl().active_tree(), 456);
+    position = gfx::PointF(60.f, 60.f);  // 70, 70 in screen space
+    bounds = gfx::Size(20, 20);
+    SetLayerPropertiesForTesting(
+        child.get(), identity_matrix, anchor, position, bounds, true, false);
+    child->SetDrawsContent(true);
+    intermediate_layer->AddChild(child.Pass());
+    root->AddChild(intermediate_layer.Pass());
+  }
+
+  host_impl().SetViewportSize(root->bounds());
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Sanity check the scenario we just created.
+  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
+  ASSERT_EQ(456, root_layer()->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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(91, 91);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  EXPECT_FALSE(result_layer);
+
+  // Hit testing for a point inside should return the child layer.
+  test_point = gfx::Point(71, 71);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(456, result_layer->id());
+
+  test_point = gfx::Point(89, 89);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(456, result_layer->id());
+}
+
+TEST_F(LayerTreeImplTest, HitTestingForMultipleLayers) {
+  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
+
+  gfx::Transform identity_matrix;
+  gfx::PointF anchor;
+  gfx::PointF position;
+  gfx::Size bounds(100, 100);
+  SetLayerPropertiesForTesting(
+      root.get(), identity_matrix, anchor, position, bounds, true, false);
+  root->SetDrawsContent(true);
+  {
+    // child 1 and child2 are initialized to overlap between x=50 and x=60.
+    // grand_child is set to overlap both child1 and child2 between y=50 and
+    // y=60.  The expected stacking order is: (front) child2, (second)
+    // grand_child, (third) child1, and (back) the root layer behind all other
+    // layers.
+
+    scoped_ptr<LayerImpl> child1 =
+        LayerImpl::Create(host_impl().active_tree(), 2);
+    scoped_ptr<LayerImpl> child2 =
+        LayerImpl::Create(host_impl().active_tree(), 3);
+    scoped_ptr<LayerImpl> grand_child1 =
+        LayerImpl::Create(host_impl().active_tree(), 4);
+
+    position = gfx::PointF(10.f, 10.f);
+    bounds = gfx::Size(50, 50);
+    SetLayerPropertiesForTesting(
+        child1.get(), identity_matrix, anchor, position, bounds, true, false);
+    child1->SetDrawsContent(true);
+
+    position = gfx::PointF(50.f, 10.f);
+    bounds = gfx::Size(50, 50);
+    SetLayerPropertiesForTesting(
+        child2.get(), identity_matrix, anchor, position, bounds, true, false);
+    child2->SetDrawsContent(true);
+
+    // Remember that grand_child is positioned with respect to its parent (i.e.
+    // child1).  In screen space, the intended position is (10, 50), with size
+    // 100 x 50.
+    position = gfx::PointF(0.f, 40.f);
+    bounds = gfx::Size(100, 50);
+    SetLayerPropertiesForTesting(grand_child1.get(),
+                                 identity_matrix,
+                                 anchor,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
+    grand_child1->SetDrawsContent(true);
+
+    child1->AddChild(grand_child1.Pass());
+    root->AddChild(child1.Pass());
+    root->AddChild(child2.Pass());
+  }
+
+  LayerImpl* child1 = root->children()[0];
+  LayerImpl* child2 = root->children()[1];
+  LayerImpl* grand_child1 = child1->children()[0];
+
+  host_impl().SetViewportSize(root->bounds());
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Sanity check the scenario we just created.
+  ASSERT_TRUE(child1);
+  ASSERT_TRUE(child2);
+  ASSERT_TRUE(grand_child1);
+  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+
+  RenderSurfaceImpl* root_render_surface = root_layer()->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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(4, result_layer->id());
+}
+
+TEST_F(LayerTreeImplTest, HitTestingForMultipleLayersAtVaryingDepths) {
+  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
+
+  gfx::Transform identity_matrix;
+  gfx::PointF anchor;
+  gfx::PointF position;
+  gfx::Size bounds(100, 100);
+  SetLayerPropertiesForTesting(
+      root.get(), identity_matrix, anchor, position, bounds, true, false);
+  root->SetDrawsContent(true);
+  root->SetShouldFlattenTransform(false);
+  root->SetIs3dSorted(true);
+  {
+    // child 1 and child2 are initialized to overlap between x=50 and x=60.
+    // grand_child is set to overlap both child1 and child2 between y=50 and
+    // y=60.  The expected stacking order is: (front) child2, (second)
+    // grand_child, (third) child1, and (back) the root layer behind all other
+    // layers.
+
+    scoped_ptr<LayerImpl> child1 =
+        LayerImpl::Create(host_impl().active_tree(), 2);
+    scoped_ptr<LayerImpl> child2 =
+        LayerImpl::Create(host_impl().active_tree(), 3);
+    scoped_ptr<LayerImpl> grand_child1 =
+        LayerImpl::Create(host_impl().active_tree(), 4);
+
+    position = gfx::PointF(10.f, 10.f);
+    bounds = gfx::Size(50, 50);
+    SetLayerPropertiesForTesting(
+        child1.get(), identity_matrix, anchor, position, bounds, true, false);
+    child1->SetDrawsContent(true);
+    child1->SetShouldFlattenTransform(false);
+    child1->SetIs3dSorted(true);
+
+    position = gfx::PointF(50.f, 10.f);
+    bounds = gfx::Size(50, 50);
+    gfx::Transform translate_z;
+    translate_z.Translate3d(0, 0, -10.f);
+    SetLayerPropertiesForTesting(
+        child2.get(), translate_z, anchor, position, bounds, true, false);
+    child2->SetDrawsContent(true);
+    child2->SetShouldFlattenTransform(false);
+    child2->SetIs3dSorted(true);
+
+    // Remember that grand_child is positioned with respect to its parent (i.e.
+    // child1).  In screen space, the intended position is (10, 50), with size
+    // 100 x 50.
+    position = gfx::PointF(0.f, 40.f);
+    bounds = gfx::Size(100, 50);
+    SetLayerPropertiesForTesting(grand_child1.get(),
+                                 identity_matrix,
+                                 anchor,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
+    grand_child1->SetDrawsContent(true);
+    grand_child1->SetShouldFlattenTransform(false);
+
+    child1->AddChild(grand_child1.Pass());
+    root->AddChild(child1.Pass());
+    root->AddChild(child2.Pass());
+  }
+
+  LayerImpl* child1 = root->children()[0];
+  LayerImpl* child2 = root->children()[1];
+  LayerImpl* grand_child1 = child1->children()[0];
+
+  host_impl().SetViewportSize(root->bounds());
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Sanity check the scenario we just created.
+  ASSERT_TRUE(child1);
+  ASSERT_TRUE(child2);
+  ASSERT_TRUE(grand_child1);
+  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+
+  RenderSurfaceImpl* root_render_surface =
+      host_impl().active_tree()->root_layer()->render_surface();
+  ASSERT_EQ(4u, root_render_surface->layer_list().size());
+  ASSERT_EQ(3, root_render_surface->layer_list().at(0)->id());
+  ASSERT_EQ(1, root_render_surface->layer_list().at(1)->id());
+  ASSERT_EQ(2, root_render_surface->layer_list().at(2)->id());
+  ASSERT_EQ(4, root_render_surface->layer_list().at(3)->id());
+
+  // 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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(2, result_layer->id());
+
+  // At (51, 20), child1 and child2 overlap. child2 is expected to be on top.
+  // (because 3 is transformed to the back).
+  test_point = gfx::Point(51, 20);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(2, result_layer->id());
+
+  // 3 Would have been on top if it hadn't been transformed to the background.
+  // Make sure that it isn't hit.
+  test_point = gfx::Point(80, 51);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(4, result_layer->id());
+
+  // 3 Would have been on top if it hadn't been transformed to the background.
+  // Make sure that it isn't hit.
+  test_point = gfx::Point(51, 51);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(4, 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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(4, result_layer->id());
+}
+
+TEST_F(LayerTreeImplTest, HitTestingForMultipleLayerLists) {
+  //
+  // The geometry is set up similarly to the previous case, but
+  // all layers are forced to be render surfaces now.
+  //
+  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
+
+  gfx::Transform identity_matrix;
+  gfx::PointF anchor;
+  gfx::PointF position;
+  gfx::Size bounds(100, 100);
+  SetLayerPropertiesForTesting(
+      root.get(), identity_matrix, anchor, position, bounds, true, false);
+  root->SetDrawsContent(true);
+  {
+    // child 1 and child2 are initialized to overlap between x=50 and x=60.
+    // grand_child is set to overlap both child1 and child2 between y=50 and
+    // y=60.  The expected stacking order is: (front) child2, (second)
+    // grand_child, (third) child1, and (back) the root layer behind all other
+    // layers.
+
+    scoped_ptr<LayerImpl> child1 =
+        LayerImpl::Create(host_impl().active_tree(), 2);
+    scoped_ptr<LayerImpl> child2 =
+        LayerImpl::Create(host_impl().active_tree(), 3);
+    scoped_ptr<LayerImpl> grand_child1 =
+        LayerImpl::Create(host_impl().active_tree(), 4);
+
+    position = gfx::PointF(10.f, 10.f);
+    bounds = gfx::Size(50, 50);
+    SetLayerPropertiesForTesting(
+        child1.get(), identity_matrix, anchor, position, bounds, true, false);
+    child1->SetDrawsContent(true);
+    child1->SetForceRenderSurface(true);
+
+    position = gfx::PointF(50.f, 10.f);
+    bounds = gfx::Size(50, 50);
+    SetLayerPropertiesForTesting(
+        child2.get(), identity_matrix, anchor, position, bounds, true, false);
+    child2->SetDrawsContent(true);
+    child2->SetForceRenderSurface(true);
+
+    // Remember that grand_child is positioned with respect to its parent (i.e.
+    // child1).  In screen space, the intended position is (10, 50), with size
+    // 100 x 50.
+    position = gfx::PointF(0.f, 40.f);
+    bounds = gfx::Size(100, 50);
+    SetLayerPropertiesForTesting(grand_child1.get(),
+                                 identity_matrix,
+                                 anchor,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
+    grand_child1->SetDrawsContent(true);
+    grand_child1->SetForceRenderSurface(true);
+
+    child1->AddChild(grand_child1.Pass());
+    root->AddChild(child1.Pass());
+    root->AddChild(child2.Pass());
+  }
+
+  LayerImpl* child1 = root->children()[0];
+  LayerImpl* child2 = root->children()[1];
+  LayerImpl* grand_child1 = child1->children()[0];
+
+  host_impl().SetViewportSize(root->bounds());
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Sanity check the scenario we just created.
+  ASSERT_TRUE(child1);
+  ASSERT_TRUE(child2);
+  ASSERT_TRUE(grand_child1);
+  ASSERT_TRUE(child1->render_surface());
+  ASSERT_TRUE(child2->render_surface());
+  ASSERT_TRUE(grand_child1->render_surface());
+  ASSERT_EQ(4u, RenderSurfaceLayerList().size());
+  // The root surface has the root layer, and child1's and child2's render
+  // surfaces.
+  ASSERT_EQ(3u, root_layer()->render_surface()->layer_list().size());
+  // The child1 surface has the child1 layer and grand_child1's render surface.
+  ASSERT_EQ(2u, child1->render_surface()->layer_list().size());
+  ASSERT_EQ(1u, child2->render_surface()->layer_list().size());
+  ASSERT_EQ(1u, grand_child1->render_surface()->layer_list().size());
+  ASSERT_EQ(1, RenderSurfaceLayerList().at(0)->id());  // root layer
+  ASSERT_EQ(2, RenderSurfaceLayerList()[1]->id());     // child1
+  ASSERT_EQ(4, RenderSurfaceLayerList().at(2)->id());  // grand_child1
+  ASSERT_EQ(3, RenderSurfaceLayerList()[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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(4, result_layer->id());
+}
+
+TEST_F(LayerTreeImplTest, HitTestingForEmptyLayers) {
+  // Layer 1 - root
+  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
+  gfx::Transform identity_matrix;
+  gfx::PointF anchor;
+  gfx::PointF position;
+  gfx::Size bounds(100, 100);
+  SetLayerPropertiesForTesting(
+      root.get(), identity_matrix, anchor, position, bounds, true, false);
+  root->SetDrawsContent(true);
+
+  {
+    // Layer 2 - empty: drawsContent=false
+    gfx::PointF position(10.f, 10.f);
+    gfx::Size bounds(30, 30);
+    scoped_ptr<LayerImpl> empty_layer =
+        LayerImpl::Create(host_impl().active_tree(), 2);
+    SetLayerPropertiesForTesting(empty_layer.get(),
+                                 identity_matrix,
+                                 anchor,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
+
+    empty_layer->SetDrawsContent(false);
+    root->AddChild(empty_layer.Pass());
+  }
+
+  {
+    // Layer 3 - empty, but has touch handler
+    gfx::PointF position(10.f, 60.f);
+    gfx::Size bounds(30, 30);
+    scoped_ptr<LayerImpl> test_layer =
+        LayerImpl::Create(host_impl().active_tree(), 3);
+    SetLayerPropertiesForTesting(test_layer.get(),
+                                 identity_matrix,
+                                 anchor,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
+
+    test_layer->SetDrawsContent(false);
+    Region touch_handler_region(gfx::Rect(10, 10, 10, 10));
+    test_layer->SetTouchEventHandlerRegion(touch_handler_region);
+    root->AddChild(test_layer.Pass());
+  }
+
+  {
+    // Layer 4 - empty, but has mousewheel handler
+    gfx::PointF position(60.f, 60.f);
+    gfx::Size bounds(30, 30);
+    scoped_ptr<LayerImpl> test_layer =
+        LayerImpl::Create(host_impl().active_tree(), 4);
+    SetLayerPropertiesForTesting(test_layer.get(),
+                                 identity_matrix,
+                                 anchor,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
+
+    test_layer->SetDrawsContent(false);
+    test_layer->SetHaveWheelEventHandlers(true);
+    root->AddChild(test_layer.Pass());
+  }
+
+  host_impl().SetViewportSize(root->bounds());
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Verify that the root layer and empty layers with touch/wheel handlers
+  // (but not the empty layer without a touch handler) are in the RSSL.
+  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  EXPECT_EQ(1, RenderSurfaceLayerList()[0]->id());
+  ASSERT_EQ(3u, root_layer()->render_surface()->layer_list().size());
+  EXPECT_EQ(1, root_layer()->render_surface()->layer_list().at(0)->id());
+  EXPECT_EQ(3, root_layer()->render_surface()->layer_list().at(1)->id());
+  EXPECT_EQ(4, root_layer()->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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(4, result_layer->id());
+}
+
+TEST_F(LayerTreeImplTest, HitCheckingTouchHandlerRegionsForSingleLayer) {
+  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;
+  gfx::PointF position;
+  gfx::Size bounds(100, 100);
+  SetLayerPropertiesForTesting(
+      root.get(), identity_matrix, anchor, position, bounds, true, false);
+  root->SetDrawsContent(true);
+
+  host_impl().SetViewportSize(root->bounds());
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Sanity check the scenario we just created.
+  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(1u, root_layer()->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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  EXPECT_FALSE(result_layer);
+
+  host_impl().active_tree()->root_layer()->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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(-1, -1);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(99, 99);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(12345, result_layer->id());
+
+  test_point = gfx::Point(59, 59);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(12345, result_layer->id());
+}
+
+TEST_F(LayerTreeImplTest,
+       HitCheckingTouchHandlerRegionsForUninvertibleTransform) {
+  scoped_ptr<LayerImpl> root =
+      LayerImpl::Create(host_impl().active_tree(), 12345);
+
+  gfx::Transform uninvertible_transform;
+  uninvertible_transform.matrix().set(0, 0, 0.0);
+  uninvertible_transform.matrix().set(1, 1, 0.0);
+  uninvertible_transform.matrix().set(2, 2, 0.0);
+  uninvertible_transform.matrix().set(3, 3, 0.0);
+  ASSERT_FALSE(uninvertible_transform.IsInvertible());
+
+  gfx::Transform identity_matrix;
+  Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
+  gfx::PointF anchor;
+  gfx::PointF position;
+  gfx::Size bounds(100, 100);
+  SetLayerPropertiesForTesting(root.get(),
+                               uninvertible_transform,
+                               anchor,
+                               position,
+                               bounds,
+                               true,
+                               false);
+  root->SetDrawsContent(true);
+  root->SetTouchEventHandlerRegion(touch_handler_region);
+
+  host_impl().SetViewportSize(root->bounds());
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Sanity check the scenario we just created.
+  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
+  ASSERT_FALSE(root_layer()->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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(10, 10);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(10, 30);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(50, 50);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(67, 48);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(99, 99);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(-1, -1);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  EXPECT_FALSE(result_layer);
+}
+
+TEST_F(LayerTreeImplTest,
+       HitCheckingTouchHandlerRegionsForSinglePositionedLayer) {
+  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;
+  // this layer is positioned, and hit testing should correctly know where the
+  // layer is located.
+  gfx::PointF position(50.f, 50.f);
+  gfx::Size bounds(100, 100);
+  SetLayerPropertiesForTesting(
+      root.get(), identity_matrix, anchor, position, bounds, true, false);
+  root->SetDrawsContent(true);
+  root->SetTouchEventHandlerRegion(touch_handler_region);
+
+  host_impl().SetViewportSize(root->bounds());
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Sanity check the scenario we just created.
+  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(1u, root_layer()->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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(12345, result_layer->id());
+
+  test_point = gfx::Point(99, 99);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(12345, result_layer->id());
+}
+
+TEST_F(LayerTreeImplTest,
+       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
+  // non-identity transform between layer's content space and layer's origin
+  // space. The hit testing code must take this into account.
+  //
+  // To test this, the layer is positioned at (25, 25), and is size (50, 50). If
+  // contents scale is ignored, then hit checking will mis-interpret the visible
+  // content rect as being larger than the actual bounds of the layer.
+  //
+  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
+
+  gfx::Transform identity_matrix;
+  gfx::PointF anchor;
+
+  SetLayerPropertiesForTesting(root.get(),
+                               identity_matrix,
+                               anchor,
+                               gfx::PointF(),
+                               gfx::Size(100, 100),
+                               true,
+                               false);
+  {
+    Region touch_handler_region(gfx::Rect(10, 10, 30, 30));
+    gfx::PointF position(25.f, 25.f);
+    gfx::Size bounds(50, 50);
+    scoped_ptr<LayerImpl> test_layer =
+        LayerImpl::Create(host_impl().active_tree(), 12345);
+    SetLayerPropertiesForTesting(test_layer.get(),
+                                 identity_matrix,
+                                 anchor,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
+
+    // override content bounds and contents scale
+    test_layer->SetContentBounds(gfx::Size(100, 100));
+    test_layer->SetContentsScale(2, 2);
+
+    test_layer->SetDrawsContent(true);
+    test_layer->SetTouchEventHandlerRegion(touch_handler_region);
+    root->AddChild(test_layer.Pass());
+  }
+
+  host_impl().SetViewportSize(root->bounds());
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Sanity check the scenario we just created.
+  // The visible content rect for test_layer is actually 100x100, even though
+  // its layout size is 50x50, positioned at 25x25.
+  LayerImpl* test_layer =
+      host_impl().active_tree()->root_layer()->children()[0];
+  EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), test_layer->visible_content_rect());
+  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(1u, root_layer()->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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(34, 34);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(65, 65);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(74, 74);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(12345, result_layer->id());
+
+  test_point = gfx::Point(64, 64);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(12345, result_layer->id());
+}
+
+TEST_F(LayerTreeImplTest,
+       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.
+  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
+
+  gfx::Transform identity_matrix;
+  gfx::PointF anchor;
+  // Set the bounds of the root layer big enough to fit the child when scaled.
+  SetLayerPropertiesForTesting(root.get(),
+                               identity_matrix,
+                               anchor,
+                               gfx::PointF(),
+                               gfx::Size(100, 100),
+                               true,
+                               false);
+  {
+    Region touch_handler_region(gfx::Rect(10, 10, 30, 30));
+    gfx::PointF position(25.f, 25.f);
+    gfx::Size bounds(50, 50);
+    scoped_ptr<LayerImpl> test_layer =
+        LayerImpl::Create(host_impl().active_tree(), 12345);
+    SetLayerPropertiesForTesting(test_layer.get(),
+                                 identity_matrix,
+                                 anchor,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
+
+    test_layer->SetDrawsContent(true);
+    test_layer->SetTouchEventHandlerRegion(touch_handler_region);
+    root->AddChild(test_layer.Pass());
+  }
+
+  float device_scale_factor = 3.f;
+  float page_scale_factor = 5.f;
+  gfx::Size scaled_bounds_for_root = gfx::ToCeiledSize(
+      gfx::ScaleSize(root->bounds(), device_scale_factor * page_scale_factor));
+  host_impl().SetViewportSize(scaled_bounds_for_root);
+
+  host_impl().SetDeviceScaleFactor(device_scale_factor);
+  host_impl().active_tree()->SetPageScaleFactorAndLimits(
+      page_scale_factor, page_scale_factor, page_scale_factor);
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->SetViewportLayersFromIds(1, 1, Layer::INVALID_ID);
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Sanity check the scenario we just created.
+  // The visible content rect for test_layer is actually 100x100, even though
+  // its layout size is 50x50, positioned at 25x25.
+  LayerImpl* test_layer =
+      host_impl().active_tree()->root_layer()->children()[0];
+  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
+
+  // Check whether the child layer fits into the root after scaled.
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(34, 34);
+  test_point =
+      gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(65, 65);
+  test_point =
+      gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(74, 74);
+  test_point =
+      gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(12345, result_layer->id());
+}
+
+TEST_F(LayerTreeImplTest, 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;
+  gfx::PointF anchor;
+
+  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
+  SetLayerPropertiesForTesting(root.get(),
+                               identity_matrix,
+                               anchor,
+                               gfx::PointF(),
+                               gfx::Size(100, 100),
+                               true,
+                               false);
+  {
+    scoped_ptr<LayerImpl> clipping_layer =
+        LayerImpl::Create(host_impl().active_tree(), 123);
+    // this layer is positioned, and hit testing should correctly know where the
+    // layer is located.
+    gfx::PointF position(25.f, 25.f);
+    gfx::Size bounds(50, 50);
+    SetLayerPropertiesForTesting(clipping_layer.get(),
+                                 identity_matrix,
+                                 anchor,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
+    clipping_layer->SetMasksToBounds(true);
+
+    scoped_ptr<LayerImpl> child =
+        LayerImpl::Create(host_impl().active_tree(), 456);
+    Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
+    position = gfx::PointF(-50.f, -50.f);
+    bounds = gfx::Size(300, 300);
+    SetLayerPropertiesForTesting(
+        child.get(), identity_matrix, anchor, position, bounds, true, false);
+    child->SetDrawsContent(true);
+    child->SetTouchEventHandlerRegion(touch_handler_region);
+    clipping_layer->AddChild(child.Pass());
+    root->AddChild(clipping_layer.Pass());
+  }
+
+  host_impl().SetViewportSize(root->bounds());
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Sanity check the scenario we just created.
+  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
+  ASSERT_EQ(456, root_layer()->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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  EXPECT_FALSE(result_layer);
+
+  test_point = gfx::Point(74, 74);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(456, result_layer->id());
+
+  test_point = gfx::Point(34, 34);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(456, result_layer->id());
+}
+
+TEST_F(LayerTreeImplTest, HitCheckingTouchHandlerOverlappingRegions) {
+  gfx::Transform identity_matrix;
+  gfx::PointF anchor;
+
+  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
+  SetLayerPropertiesForTesting(root.get(),
+                               identity_matrix,
+                               anchor,
+                               gfx::PointF(),
+                               gfx::Size(100, 100),
+                               true,
+                               false);
+  {
+    scoped_ptr<LayerImpl> touch_layer =
+        LayerImpl::Create(host_impl().active_tree(), 123);
+    // this layer is positioned, and hit testing should correctly know where the
+    // layer is located.
+    gfx::PointF position;
+    gfx::Size bounds(50, 50);
+    SetLayerPropertiesForTesting(touch_layer.get(),
+                                 identity_matrix,
+                                 anchor,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
+    touch_layer->SetDrawsContent(true);
+    touch_layer->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 50, 50));
+    root->AddChild(touch_layer.Pass());
+  }
+
+  {
+    scoped_ptr<LayerImpl> notouch_layer =
+        LayerImpl::Create(host_impl().active_tree(), 1234);
+    // this layer is positioned, and hit testing should correctly know where the
+    // layer is located.
+    gfx::PointF position(0, 25);
+    gfx::Size bounds(50, 50);
+    SetLayerPropertiesForTesting(notouch_layer.get(),
+                                 identity_matrix,
+                                 anchor,
+                                 position,
+                                 bounds,
+                                 true,
+                                 false);
+    notouch_layer->SetDrawsContent(true);
+    root->AddChild(notouch_layer.Pass());
+  }
+
+  host_impl().SetViewportSize(root->bounds());
+  host_impl().active_tree()->SetRootLayer(root.Pass());
+  host_impl().active_tree()->UpdateDrawProperties();
+
+  // Sanity check the scenario we just created.
+  ASSERT_EQ(1u, RenderSurfaceLayerList().size());
+  ASSERT_EQ(2u, root_layer()->render_surface()->layer_list().size());
+  ASSERT_EQ(123, root_layer()->render_surface()->layer_list().at(0)->id());
+  ASSERT_EQ(1234, root_layer()->render_surface()->layer_list().at(1)->id());
+
+  gfx::Point test_point(35, 35);
+  LayerImpl* result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+
+  // 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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+
+  // 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 =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(123, result_layer->id());
+
+  test_point = gfx::Point(35, 65);
+  result_layer =
+      host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
+          test_point);
+  EXPECT_FALSE(result_layer);
+}
+
+}  // namespace
+}  // namespace cc