cc: Don't consider HUD layer for touches

cc/layer_tree_host_impl_unittest.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layer_tree_host_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/hash_tables.h"
 #include "cc/compositor_frame_metadata.h"
 #include "cc/delegated_renderer_layer_impl.h"
 #include "cc/gl_renderer.h"
 #include "cc/heads_up_display_layer_impl.h"
 #include "cc/io_surface_layer_impl.h"
+#include "cc/layer.h"
 #include "cc/layer_impl.h"
 #include "cc/layer_tiling_data.h"
 #include "cc/layer_tree_impl.h"
 #include "cc/math_util.h"
 #include "cc/quad_sink.h"
 #include "cc/render_pass_draw_quad.h"
 #include "cc/scrollbar_geometry_fixed_thumb.h"
 #include "cc/scrollbar_layer_impl.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/test/animation_test_common.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/fake_proxy.h"
 #include "cc/test/fake_video_frame_provider.h"
 #include "cc/test/fake_web_scrollbar_theme_geometry.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_test_common.h"
 #include "cc/test/render_pass_test_common.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/texture_draw_quad.h"
 #include "cc/texture_layer_impl.h"
 #include "cc/tile_draw_quad.h"
 #include "cc/tiled_layer_impl.h"
 #include "cc/video_layer_impl.h"
 #include "media/base/media.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/vector2d_conversions.h"
 
 using ::testing::Mock;
 using ::testing::Return;
 using ::testing::AnyNumber;
 using ::testing::AtLeast;
 using ::testing::_;
 using media::VideoFrame;
 
 namespace cc {
 namespace {
 
+template<typename LayerType>
+void setLayerPropertiesForTestingInternal(LayerType* layer, const gfx::Transform& transform, const gfx::Transform& sublayerTransform, const gfx::PointF& anchor, const gfx::PointF& position, const gfx::Size& bounds, bool preserves3D)
+{
+    layer->setTransform(transform);
+    layer->setSublayerTransform(sublayerTransform);
+    layer->setAnchorPoint(anchor);
+    layer->setPosition(position);
+    layer->setBounds(bounds);
+    layer->setPreserves3D(preserves3D);
+}
+
+void setLayerPropertiesForTesting(Layer* layer, const gfx::Transform& transform, const gfx::Transform& sublayerTransform, const gfx::PointF& anchor, const gfx::PointF& position, const gfx::Size& bounds, bool preserves3D)
+{
+    setLayerPropertiesForTestingInternal<Layer>(layer, transform, sublayerTransform, anchor, position, bounds, preserves3D);
+    layer->setAutomaticallyComputeRasterScale(true);
+}
+
+void setLayerPropertiesForTesting(LayerImpl* layer, const gfx::Transform& transform, const gfx::Transform& sublayerTransform, const gfx::PointF& anchor, const gfx::PointF& position, const gfx::Size& bounds, bool preserves3D)
+{
+    setLayerPropertiesForTestingInternal<LayerImpl>(layer, transform, sublayerTransform, anchor, position, bounds, preserves3D);
+    layer->setContentBounds(bounds);
+}
+
 // This test is parametrized to run all tests with the
 // m_settings.pageScalePinchZoomEnabled field enabled and disabled.
 class LayerTreeHostImplTest : public testing::TestWithParam<bool>,
                               public LayerTreeHostImplClient {
 public:
     LayerTreeHostImplTest()
         : m_proxy(scoped_ptr<Thread>(NULL))
         , m_alwaysImplThread(&m_proxy)
         , m_alwaysMainThreadBlocked(&m_proxy)
         , m_onCanDrawStateChangedCalled(false)
@@ skipping 4269 matching lines @@
         ASSERT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
         const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
         EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), renderPassQuad->rect.ToString());
         EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(), renderPassQuad->mask_uv_rect.ToString());
 
         m_hostImpl->drawLayers(frame);
         m_hostImpl->didDrawAllLayers(frame);
     }
 }
 
+TEST(LayerTreeHostImplTest, verifyHitTestingForEmptyLayerList)
+{
+    FakeImplProxy proxy;
+    FakeLayerTreeHostImpl hostImpl(&proxy);
+
+    // Hit testing on an empty renderSurfaceLayerList should return a null pointer.
+    std::vector<LayerImpl*> renderSurfaceLayerList;
+
+    gfx::Point testPoint(0, 0);
+    LayerImpl* resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(10, 20);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+}
+
+TEST(LayerTreeHostImplTest, verifyHitTestingForSingleLayer)
+{
+    FakeImplProxy proxy;
+    FakeLayerTreeHostImpl hostImpl(&proxy);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 12345);
+
+    gfx::Transform identityMatrix;
+    gfx::PointF anchor(0, 0);
+    gfx::PointF position(0, 0);
+    gfx::Size bounds(100, 100);
+    setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
+    root->setDrawsContent(true);
+
+    std::vector<LayerImpl*> renderSurfaceLayerList;
+    int dummyMaxTextureSize = 512;
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList, false);
+
+    // Sanity check the scenario we just created.
+    ASSERT_EQ(1u, renderSurfaceLayerList.size());
+    ASSERT_EQ(1u, root->renderSurface()->layerList().size());
+
+    // Hit testing for a point outside the layer should return a null pointer.
+    gfx::Point testPoint(101, 101);
+    LayerImpl* resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(-1, -1);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Hit testing for a point inside should return the root layer.
+    testPoint = gfx::Point(1, 1);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(12345, resultLayer->id());
+
+    testPoint = gfx::Point(99, 99);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(12345, resultLayer->id());
+}
+
+TEST(LayerTreeHostImplTest, verifyHitTestingForUninvertibleTransform)
+{
+    FakeImplProxy proxy;
+    FakeLayerTreeHostImpl hostImpl(&proxy);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 12345);
+
+    gfx::Transform uninvertibleTransform;
+    uninvertibleTransform.matrix().setDouble(0, 0, 0);
+    uninvertibleTransform.matrix().setDouble(1, 1, 0);
+    uninvertibleTransform.matrix().setDouble(2, 2, 0);
+    uninvertibleTransform.matrix().setDouble(3, 3, 0);
+    ASSERT_FALSE(uninvertibleTransform.IsInvertible());
+
+    gfx::Transform identityMatrix;
+    gfx::PointF anchor(0, 0);
+    gfx::PointF position(0, 0);
+    gfx::Size bounds(100, 100);
+    setLayerPropertiesForTesting(root.get(), uninvertibleTransform, identityMatrix, anchor, position, bounds, false);
+    root->setDrawsContent(true);
+
+    std::vector<LayerImpl*> renderSurfaceLayerList;
+    int dummyMaxTextureSize = 512;
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList, false);
+
+    // Sanity check the scenario we just created.
+    ASSERT_EQ(1u, renderSurfaceLayerList.size());
+    ASSERT_EQ(1u, root->renderSurface()->layerList().size());
+    ASSERT_FALSE(root->screenSpaceTransform().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 testPoint(1, 1);
+    LayerImpl* resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(10, 10);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(10, 30);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(50, 50);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(67, 48);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(99, 99);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(-1, -1);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+}
+
+TEST(LayerTreeHostImplTest, verifyHitTestingForSinglePositionedLayer)
+{
+    FakeImplProxy proxy;
+    FakeLayerTreeHostImpl hostImpl(&proxy);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 12345);
+
+    gfx::Transform identityMatrix;
+    gfx::PointF anchor(0, 0);
+    gfx::PointF position(50, 50); // this layer is positioned, and hit testing should correctly know where the layer is located.
+    gfx::Size bounds(100, 100);
+    setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
+    root->setDrawsContent(true);
+
+    std::vector<LayerImpl*> renderSurfaceLayerList;
+    int dummyMaxTextureSize = 512;
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList, false);
+
+    // Sanity check the scenario we just created.
+    ASSERT_EQ(1u, renderSurfaceLayerList.size());
+    ASSERT_EQ(1u, root->renderSurface()->layerList().size());
+
+    // Hit testing for a point outside the layer should return a null pointer.
+    gfx::Point testPoint(49, 49);
+    LayerImpl* resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Even though the layer exists at (101, 101), it should not be visible there since the root renderSurface would clamp it.
+    testPoint = gfx::Point(101, 101);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Hit testing for a point inside should return the root layer.
+    testPoint = gfx::Point(51, 51);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(12345, resultLayer->id());
+
+    testPoint = gfx::Point(99, 99);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(12345, resultLayer->id());
+}
+
+TEST(LayerTreeHostImplTest, verifyHitTestingForSingleRotatedLayer)
+{
+    FakeImplProxy proxy;
+    FakeLayerTreeHostImpl hostImpl(&proxy);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 12345);
+
+    gfx::Transform identityMatrix;
+    gfx::Transform rotation45DegreesAboutCenter;
+    rotation45DegreesAboutCenter.Translate(50, 50);
+    rotation45DegreesAboutCenter.RotateAboutZAxis(45);
+    rotation45DegreesAboutCenter.Translate(-50, -50);
+    gfx::PointF anchor(0, 0);
+    gfx::PointF position(0, 0);
+    gfx::Size bounds(100, 100);
+    setLayerPropertiesForTesting(root.get(), rotation45DegreesAboutCenter, identityMatrix, anchor, position, bounds, false);
+    root->setDrawsContent(true);
+
+    std::vector<LayerImpl*> renderSurfaceLayerList;
+    int dummyMaxTextureSize = 512;
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList, false);
+
+    // Sanity check the scenario we just created.
+    ASSERT_EQ(1u, renderSurfaceLayerList.size());
+    ASSERT_EQ(1u, root->renderSurface()->layerList().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 testPoint(99, 99);
+    LayerImpl* resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(1, 1);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Hit testing for a point inside should return the root layer.
+    testPoint = gfx::Point(1, 50);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(12345, resultLayer->id());
+
+    // Hit testing the corners that would overlap the unclipped layer, but are outside the clipped region.
+    testPoint = gfx::Point(50, -1);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(-1, 50);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_FALSE(resultLayer);
+}
+
+TEST(LayerTreeHostImplTest, verifyHitTestingForSinglePerspectiveLayer)
+{
+    FakeImplProxy proxy;
+    FakeLayerTreeHostImpl hostImpl(&proxy);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 12345);
+
+    gfx::Transform identityMatrix;
+
+    // perspectiveProjectionAboutCenter * translationByZ is designed so that the 100 x 100 layer becomes 50 x 50, and remains centered at (50, 50).
+    gfx::Transform perspectiveProjectionAboutCenter;
+    perspectiveProjectionAboutCenter.Translate(50, 50);
+    perspectiveProjectionAboutCenter.ApplyPerspectiveDepth(1);
+    perspectiveProjectionAboutCenter.Translate(-50, -50);
+    gfx::Transform translationByZ;
+    translationByZ.Translate3d(0, 0, -1);
+
+    gfx::PointF anchor(0, 0);
+    gfx::PointF position(0, 0);
+    gfx::Size bounds(100, 100);
+    setLayerPropertiesForTesting(root.get(), perspectiveProjectionAboutCenter * translationByZ, identityMatrix, anchor, position, bounds, false);
+    root->setDrawsContent(true);
+
+    std::vector<LayerImpl*> renderSurfaceLayerList;
+    int dummyMaxTextureSize = 512;
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList, false);
+
+    // Sanity check the scenario we just created.
+    ASSERT_EQ(1u, renderSurfaceLayerList.size());
+    ASSERT_EQ(1u, root->renderSurface()->layerList().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 testPoint(24, 24);
+    LayerImpl* resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(76, 76);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Hit testing for a point inside should return the root layer.
+    testPoint = gfx::Point(26, 26);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(12345, resultLayer->id());
+
+    testPoint = gfx::Point(74, 74);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(12345, resultLayer->id());
+}
+
+TEST(LayerTreeHostImplTest, verifyHitTestingForSingleLayerWithScaledContents)
+{
+    // A layer's visibleContentRect is actually in the layer's content space. The
+    // screenSpaceTransform 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 contentsScale 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
+    // contentsScale is ignored, then hit testing will mis-interpret the visibleContentRect
+    // as being larger than the actual bounds of the layer.
+    //
+    FakeImplProxy proxy;
+    FakeLayerTreeHostImpl hostImpl(&proxy);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 1);
+
+    gfx::Transform identityMatrix;
+    gfx::PointF anchor(0, 0);
+
+    setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
+
+    {
+        gfx::PointF position(25, 25);
+        gfx::Size bounds(50, 50);
+        scoped_ptr<LayerImpl> testLayer = LayerImpl::create(hostImpl.activeTree(), 12345);
+        setLayerPropertiesForTesting(testLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
+
+        // override contentBounds and contentsScale
+        testLayer->setContentBounds(gfx::Size(100, 100));
+        testLayer->setContentsScale(2, 2);
+
+        testLayer->setDrawsContent(true);
+        root->addChild(testLayer.Pass());
+    }
+
+    std::vector<LayerImpl*> renderSurfaceLayerList;
+    int dummyMaxTextureSize = 512;
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList, false);
+
+    // Sanity check the scenario we just created.
+    // The visibleContentRect for testLayer is actually 100x100, even though its layout size is 50x50, positioned at 25x25.
+    LayerImpl* testLayer = root->children()[0];
+    EXPECT_RECT_EQ(gfx::Rect(gfx::Point(), gfx::Size(100, 100)), testLayer->visibleContentRect());
+    ASSERT_EQ(1u, renderSurfaceLayerList.size());
+    ASSERT_EQ(1u, root->renderSurface()->layerList().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 testPoint(101, 101);
+    LayerImpl* resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(24, 24);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(76, 76);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Hit testing for a point inside should return the test layer.
+    testPoint = gfx::Point(26, 26);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(12345, resultLayer->id());
+
+    testPoint = gfx::Point(74, 74);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(12345, resultLayer->id());
+}
+
+TEST(LayerTreeHostImplTest, verifyHitTestingForSimpleClippedLayer)
+{
+    // 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 identityMatrix;
+    gfx::PointF anchor(0, 0);
+
+    FakeImplProxy proxy;
+    FakeLayerTreeHostImpl hostImpl(&proxy);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 1);
+    setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
+
+    {
+        scoped_ptr<LayerImpl> clippingLayer = LayerImpl::create(hostImpl.activeTree(), 123);
+        gfx::PointF position(25, 25); // this layer is positioned, and hit testing should correctly know where the layer is located.
+        gfx::Size bounds(50, 50);
+        setLayerPropertiesForTesting(clippingLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
+        clippingLayer->setMasksToBounds(true);
+
+        scoped_ptr<LayerImpl> child = LayerImpl::create(hostImpl.activeTree(), 456);
+        position = gfx::PointF(-50, -50);
+        bounds = gfx::Size(300, 300);
+        setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
+        child->setDrawsContent(true);
+        clippingLayer->addChild(child.Pass());
+        root->addChild(clippingLayer.Pass());
+    }
+
+    std::vector<LayerImpl*> renderSurfaceLayerList;
+    int dummyMaxTextureSize = 512;
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList, false);
+
+    // Sanity check the scenario we just created.
+    ASSERT_EQ(1u, renderSurfaceLayerList.size());
+    ASSERT_EQ(1u, root->renderSurface()->layerList().size());
+    ASSERT_EQ(456, root->renderSurface()->layerList()[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 testPoint(24, 24);
+    LayerImpl* resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Even though the layer exists at (101, 101), it should not be visible there since the clippingLayer would clamp it.
+    testPoint = gfx::Point(76, 76);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Hit testing for a point inside should return the child layer.
+    testPoint = gfx::Point(26, 26);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(456, resultLayer->id());
+
+    testPoint = gfx::Point(74, 74);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(456, resultLayer->id());
+}
+
+TEST(LayerTreeHostImplTest, verifyHitTestingForMultiClippedRotatedLayer)
+{
+    // 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 grandChild layers are both initialized to clip the rotatedLeaf. The
+    // child layer is rotated about the top-left corner, so that the root + child clips
+    // combined create a triangle. The rotatedLeaf will only be visible where it overlaps
+    // this triangle.
+    //
+    FakeImplProxy proxy;
+    FakeLayerTreeHostImpl hostImpl(&proxy);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 123);
+
+    gfx::Transform identityMatrix;
+    gfx::PointF anchor(0, 0);
+    gfx::PointF position(0, 0);
+    gfx::Size bounds(100, 100);
+    setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
+    root->setMasksToBounds(true);
+
+    {
+        scoped_ptr<LayerImpl> child = LayerImpl::create(hostImpl.activeTree(), 456);
+        scoped_ptr<LayerImpl> grandChild = LayerImpl::create(hostImpl.activeTree(), 789);
+        scoped_ptr<LayerImpl> rotatedLeaf = LayerImpl::create(hostImpl.activeTree(), 2468);
+
+        position = gfx::PointF(10, 10);
+        bounds = gfx::Size(80, 80);
+        setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
+        child->setMasksToBounds(true);
+
+        gfx::Transform rotation45DegreesAboutCorner;
+        rotation45DegreesAboutCorner.RotateAboutZAxis(45);
+
+        position = gfx::PointF(0, 0); // remember, positioned with respect to its parent which is already at 10, 10
+        bounds = gfx::Size(200, 200); // to ensure it covers at least sqrt(2) * 100.
+        setLayerPropertiesForTesting(grandChild.get(), rotation45DegreesAboutCorner, identityMatrix, anchor, position, bounds, false);
+        grandChild->setMasksToBounds(true);
+
+        // Rotates about the center of the layer
+        gfx::Transform rotatedLeafTransform;
+        rotatedLeafTransform.Translate(-10, -10); // cancel out the grandParent's position
+        rotatedLeafTransform.RotateAboutZAxis(-45); // cancel out the corner 45-degree rotation of the parent.
+        rotatedLeafTransform.Translate(50, 50);
+        rotatedLeafTransform.RotateAboutZAxis(45);
+        rotatedLeafTransform.Translate(-50, -50);
+        position = gfx::PointF(0, 0);
+        bounds = gfx::Size(100, 100);
+        setLayerPropertiesForTesting(rotatedLeaf.get(), rotatedLeafTransform, identityMatrix, anchor, position, bounds, false);
+        rotatedLeaf->setDrawsContent(true);
+
+        grandChild->addChild(rotatedLeaf.Pass());
+        child->addChild(grandChild.Pass());
+        root->addChild(child.Pass());
+    }
+
+    std::vector<LayerImpl*> renderSurfaceLayerList;
+    int dummyMaxTextureSize = 512;
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList, false);
+
+    // Sanity check the scenario we just created.
+    // The grandChild is expected to create a renderSurface because it masksToBounds and is not axis aligned.
+    ASSERT_EQ(2u, renderSurfaceLayerList.size());
+    ASSERT_EQ(1u, renderSurfaceLayerList[0]->renderSurface()->layerList().size());
+    ASSERT_EQ(789, renderSurfaceLayerList[0]->renderSurface()->layerList()[0]->id()); // grandChild's surface.
+    ASSERT_EQ(1u, renderSurfaceLayerList[1]->renderSurface()->layerList().size());
+    ASSERT_EQ(2468, renderSurfaceLayerList[1]->renderSurface()->layerList()[0]->id());
+
+    // (11, 89) is close to the the bottom left corner within the clip, but it is not inside the layer.
+    gfx::Point testPoint(11, 89);
+    LayerImpl* resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Closer inwards from the bottom left will overlap the layer.
+    testPoint = gfx::Point(25, 75);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(2468, resultLayer->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
+    // visibleContentRect without considering how parent may clip the layer, then hit
+    // testing would accidentally think that the point successfully hits the layer.
+    testPoint = gfx::Point(4, 50);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // (11, 50) is inside the layer and within the clipped area.
+    testPoint = gfx::Point(11, 50);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(2468, resultLayer->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.
+    testPoint = gfx::Point(51, 51);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Around the middle, just to the left and down, should successfully hit the layer.
+    testPoint = gfx::Point(49, 51);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(2468, resultLayer->id());
+}
+
+TEST(LayerTreeHostImplTest, verifyHitTestingForNonClippingIntermediateLayer)
+{
+    // This test checks that hit testing code does not accidentally clip to layer
+    // bounds for a layer that actually does not clip.
+    gfx::Transform identityMatrix;
+    gfx::PointF anchor(0, 0);
+
+    FakeImplProxy proxy;
+    FakeLayerTreeHostImpl hostImpl(&proxy);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 1);
+    setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
+
+    {
+        scoped_ptr<LayerImpl> intermediateLayer = LayerImpl::create(hostImpl.activeTree(), 123);
+        gfx::PointF position(10, 10); // this layer is positioned, and hit testing should correctly know where the layer is located.
+        gfx::Size bounds(50, 50);
+        setLayerPropertiesForTesting(intermediateLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
+        // Sanity check the intermediate layer should not clip.
+        ASSERT_FALSE(intermediateLayer->masksToBounds());
+        ASSERT_FALSE(intermediateLayer->maskLayer());
+
+        // The child of the intermediateLayer is translated so that it does not overlap intermediateLayer at all.
+        // If child is incorrectly clipped, we would not be able to hit it successfully.
+        scoped_ptr<LayerImpl> child = LayerImpl::create(hostImpl.activeTree(), 456);
+        position = gfx::PointF(60, 60); // 70, 70 in screen space
+        bounds = gfx::Size(20, 20);
+        setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
+        child->setDrawsContent(true);
+        intermediateLayer->addChild(child.Pass());
+        root->addChild(intermediateLayer.Pass());
+    }
+
+    std::vector<LayerImpl*> renderSurfaceLayerList;
+    int dummyMaxTextureSize = 512;
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList, false);
+
+    // Sanity check the scenario we just created.
+    ASSERT_EQ(1u, renderSurfaceLayerList.size());
+    ASSERT_EQ(1u, root->renderSurface()->layerList().size());
+    ASSERT_EQ(456, root->renderSurface()->layerList()[0]->id());
+
+    // Hit testing for a point outside the layer should return a null pointer.
+    gfx::Point testPoint(69, 69);
+    LayerImpl* resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(91, 91);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Hit testing for a point inside should return the child layer.
+    testPoint = gfx::Point(71, 71);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(456, resultLayer->id());
+
+    testPoint = gfx::Point(89, 89);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(456, resultLayer->id());
+}
+
+
+TEST(LayerTreeHostImplTest, verifyHitTestingForMultipleLayers)
+{
+    FakeImplProxy proxy;
+    FakeLayerTreeHostImpl hostImpl(&proxy);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 1);
+
+    gfx::Transform identityMatrix;
+    gfx::PointF anchor(0, 0);
+    gfx::PointF position(0, 0);
+    gfx::Size bounds(100, 100);
+    setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
+    root->setDrawsContent(true);
+
+    {
+        // child 1 and child2 are initialized to overlap between x=50 and x=60.
+        // grandChild is set to overlap both child1 and child2 between y=50 and y=60.
+        // The expected stacking order is:
+        //   (front) child2, (second) grandChild, (third) child1, and (back) the root layer behind all other layers.
+
+        scoped_ptr<LayerImpl> child1 = LayerImpl::create(hostImpl.activeTree(), 2);
+        scoped_ptr<LayerImpl> child2 = LayerImpl::create(hostImpl.activeTree(), 3);
+        scoped_ptr<LayerImpl> grandChild1 = LayerImpl::create(hostImpl.activeTree(), 4);
+
+        position = gfx::PointF(10, 10);
+        bounds = gfx::Size(50, 50);
+        setLayerPropertiesForTesting(child1.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
+        child1->setDrawsContent(true);
+
+        position = gfx::PointF(50, 10);
+        bounds = gfx::Size(50, 50);
+        setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
+        child2->setDrawsContent(true);
+
+        // Remember that grandChild 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, 40);
+        bounds = gfx::Size(100, 50);
+        setLayerPropertiesForTesting(grandChild1.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
+        grandChild1->setDrawsContent(true);
+
+        child1->addChild(grandChild1.Pass());
+        root->addChild(child1.Pass());
+        root->addChild(child2.Pass());
+    }
+
+    LayerImpl* child1 = root->children()[0];
+    LayerImpl* child2 = root->children()[1];
+    LayerImpl* grandChild1 = child1->children()[0];
+
+    std::vector<LayerImpl*> renderSurfaceLayerList;
+    int dummyMaxTextureSize = 512;
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList, false);
+
+    // Sanity check the scenario we just created.
+    ASSERT_TRUE(child1);
+    ASSERT_TRUE(child2);
+    ASSERT_TRUE(grandChild1);
+    ASSERT_EQ(1u, renderSurfaceLayerList.size());
+    ASSERT_EQ(4u, root->renderSurface()->layerList().size());
+    ASSERT_EQ(1, root->renderSurface()->layerList()[0]->id()); // root layer
+    ASSERT_EQ(2, root->renderSurface()->layerList()[1]->id()); // child1
+    ASSERT_EQ(4, root->renderSurface()->layerList()[2]->id()); // grandChild1
+    ASSERT_EQ(3, root->renderSurface()->layerList()[3]->id()); // child2
+
+    // Nothing overlaps the rootLayer at (1, 1), so hit testing there should find the root layer.
+    gfx::Point testPoint = gfx::Point(1, 1);
+    LayerImpl* resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(1, resultLayer->id());
+
+    // At (15, 15), child1 and root are the only layers. child1 is expected to be on top.
+    testPoint = gfx::Point(15, 15);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(2, resultLayer->id());
+
+    // At (51, 20), child1 and child2 overlap. child2 is expected to be on top.
+    testPoint = gfx::Point(51, 20);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(3, resultLayer->id());
+
+    // At (80, 51), child2 and grandChild1 overlap. child2 is expected to be on top.
+    testPoint = gfx::Point(80, 51);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(3, resultLayer->id());
+
+    // At (51, 51), all layers overlap each other. child2 is expected to be on top of all other layers.
+    testPoint = gfx::Point(51, 51);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(3, resultLayer->id());
+
+    // At (20, 51), child1 and grandChild1 overlap. grandChild1 is expected to be on top.
+    testPoint = gfx::Point(20, 51);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(4, resultLayer->id());
+}
+
+TEST(LayerTreeHostImplTest, verifyHitTestingForMultipleLayerLists)
+{
+    //
+    // The geometry is set up similarly to the previous case, but
+    // all layers are forced to be renderSurfaces now.
+    //
+    FakeImplProxy proxy;
+    FakeLayerTreeHostImpl hostImpl(&proxy);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 1);
+
+    gfx::Transform identityMatrix;
+    gfx::PointF anchor(0, 0);
+    gfx::PointF position(0, 0);
+    gfx::Size bounds(100, 100);
+    setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
+    root->setDrawsContent(true);
+
+    {
+        // child 1 and child2 are initialized to overlap between x=50 and x=60.
+        // grandChild is set to overlap both child1 and child2 between y=50 and y=60.
+        // The expected stacking order is:
+        //   (front) child2, (second) grandChild, (third) child1, and (back) the root layer behind all other layers.
+
+        scoped_ptr<LayerImpl> child1 = LayerImpl::create(hostImpl.activeTree(), 2);
+        scoped_ptr<LayerImpl> child2 = LayerImpl::create(hostImpl.activeTree(), 3);
+        scoped_ptr<LayerImpl> grandChild1 = LayerImpl::create(hostImpl.activeTree(), 4);
+
+        position = gfx::PointF(10, 10);
+        bounds = gfx::Size(50, 50);
+        setLayerPropertiesForTesting(child1.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
+        child1->setDrawsContent(true);
+        child1->setForceRenderSurface(true);
+
+        position = gfx::PointF(50, 10);
+        bounds = gfx::Size(50, 50);
+        setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
+        child2->setDrawsContent(true);
+        child2->setForceRenderSurface(true);
+
+        // Remember that grandChild 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, 40);
+        bounds = gfx::Size(100, 50);
+        setLayerPropertiesForTesting(grandChild1.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
+        grandChild1->setDrawsContent(true);
+        grandChild1->setForceRenderSurface(true);
+
+        child1->addChild(grandChild1.Pass());
+        root->addChild(child1.Pass());
+        root->addChild(child2.Pass());
+    }
+
+    LayerImpl* child1 = root->children()[0];
+    LayerImpl* child2 = root->children()[1];
+    LayerImpl* grandChild1 = child1->children()[0];
+
+    std::vector<LayerImpl*> renderSurfaceLayerList;
+    int dummyMaxTextureSize = 512;
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList, false);
+
+    // Sanity check the scenario we just created.
+    ASSERT_TRUE(child1);
+    ASSERT_TRUE(child2);
+    ASSERT_TRUE(grandChild1);
+    ASSERT_TRUE(child1->renderSurface());
+    ASSERT_TRUE(child2->renderSurface());
+    ASSERT_TRUE(grandChild1->renderSurface());
+    ASSERT_EQ(4u, renderSurfaceLayerList.size());
+    ASSERT_EQ(3u, root->renderSurface()->layerList().size()); // The root surface has the root layer, and child1's and child2's renderSurfaces.
+    ASSERT_EQ(2u, child1->renderSurface()->layerList().size()); // The child1 surface has the child1 layer and grandChild1's renderSurface.
+    ASSERT_EQ(1u, child2->renderSurface()->layerList().size());
+    ASSERT_EQ(1u, grandChild1->renderSurface()->layerList().size());
+    ASSERT_EQ(1, renderSurfaceLayerList[0]->id()); // root layer
+    ASSERT_EQ(2, renderSurfaceLayerList[1]->id()); // child1
+    ASSERT_EQ(4, renderSurfaceLayerList[2]->id()); // grandChild1
+    ASSERT_EQ(3, renderSurfaceLayerList[3]->id()); // child2
+
+    // Nothing overlaps the rootLayer at (1, 1), so hit testing there should find the root layer.
+    gfx::Point testPoint = gfx::Point(1, 1);
+    LayerImpl* resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(1, resultLayer->id());
+
+    // At (15, 15), child1 and root are the only layers. child1 is expected to be on top.
+    testPoint = gfx::Point(15, 15);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(2, resultLayer->id());
+
+    // At (51, 20), child1 and child2 overlap. child2 is expected to be on top.
+    testPoint = gfx::Point(51, 20);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(3, resultLayer->id());
+
+    // At (80, 51), child2 and grandChild1 overlap. child2 is expected to be on top.
+    testPoint = gfx::Point(80, 51);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(3, resultLayer->id());
+
+    // At (51, 51), all layers overlap each other. child2 is expected to be on top of all other layers.
+    testPoint = gfx::Point(51, 51);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(3, resultLayer->id());
+
+    // At (20, 51), child1 and grandChild1 overlap. grandChild1 is expected to be on top.
+    testPoint = gfx::Point(20, 51);
+    resultLayer = hostImpl.findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(4, resultLayer->id());
+}
+
 INSTANTIATE_TEST_CASE_P(LayerTreeHostImplTests,
                         LayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 }  // namespace
 }  // namespace cc