From 28336d567bf426294b8d64e3320f42eced553ea8 Mon Sep 17 00:00:00 2001 From: "vollick@chromium.org" Date: Mon, 12 May 2014 19:07:28 +0000 Subject: Hit test on the layer tree rather than the RSLL R=danakj@chromium.org,enne@chromium.org BUG=369757,368935 Review URL: https://codereview.chromium.org/266913021 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@269835 0039d316-1c4b-4281-b951-d872f2087c98 --- cc/trees/layer_tree_impl_unittest.cc | 1940 ++++++++++++++++++++++++++++++++++ 1 file changed, 1940 insertions(+) create mode 100644 cc/trees/layer_tree_impl_unittest.cc (limited to '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 0000000..b27a06e --- /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())); + } + + 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 host_impl_; +}; + +TEST_F(LayerTreeImplTest, HitTestingForSingleLayer) { + scoped_ptr 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 root = + LayerImpl::Create(host_impl().active_tree(), 12345); + scoped_ptr 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()); + + 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 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 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 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 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 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 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 root = LayerImpl::Create(host_impl().active_tree(), 1); + SetLayerPropertiesForTesting(root.get(), + identity_matrix, + anchor, + gfx::PointF(), + gfx::Size(100, 100), + true, + false); + { + scoped_ptr 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 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 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 child = + LayerImpl::Create(host_impl().active_tree(), 456); + scoped_ptr grand_child = + LayerImpl::Create(host_impl().active_tree(), 789); + scoped_ptr 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 root = LayerImpl::Create(host_impl().active_tree(), 1); + SetLayerPropertiesForTesting(root.get(), + identity_matrix, + anchor, + gfx::PointF(), + gfx::Size(100, 100), + true, + false); + { + scoped_ptr 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 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 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 child1 = + LayerImpl::Create(host_impl().active_tree(), 2); + scoped_ptr child2 = + LayerImpl::Create(host_impl().active_tree(), 3); + scoped_ptr 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 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 child1 = + LayerImpl::Create(host_impl().active_tree(), 2); + scoped_ptr child2 = + LayerImpl::Create(host_impl().active_tree(), 3); + scoped_ptr 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 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 child1 = + LayerImpl::Create(host_impl().active_tree(), 2); + scoped_ptr child2 = + LayerImpl::Create(host_impl().active_tree(), 3); + scoped_ptr 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 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 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 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 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 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 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 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 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 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 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 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 root = LayerImpl::Create(host_impl().active_tree(), 1); + SetLayerPropertiesForTesting(root.get(), + identity_matrix, + anchor, + gfx::PointF(), + gfx::Size(100, 100), + true, + false); + { + scoped_ptr 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 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 root = LayerImpl::Create(host_impl().active_tree(), 1); + SetLayerPropertiesForTesting(root.get(), + identity_matrix, + anchor, + gfx::PointF(), + gfx::Size(100, 100), + true, + false); + { + scoped_ptr 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 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 -- cgit v1.1