Add API for hit testing layer_impl touchEventHandlerRegions from the host

cc/layer_tree_host_common_unittest.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "cc/layer_tree_host_common.h"
 
 #include "cc/content_layer.h"
 #include "cc/content_layer_client.h"
@@ skipping 3091 matching lines @@
 
     {
         scoped_ptr<LayerImpl> child = LayerImpl::create(456);
         scoped_ptr<LayerImpl> grandChild = LayerImpl::create(789);
         scoped_ptr<LayerImpl> rotatedLeaf = LayerImpl::create(2468);
 
         position = gfx::PointF(10, 10);
         bounds = gfx::Size(80, 80);
         setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         child->setMasksToBounds(true);
-        
+
         WebTransformationMatrix rotation45DegreesAboutCorner;
         rotation45DegreesAboutCorner.rotate3d(0, 0, 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
         WebTransformationMatrix rotatedLeafTransform;
@@ skipping 333 matching lines @@
     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 = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(4, resultLayer->id());
 }
 
+TEST(LayerTreeHostCommonTest, verifyHitCheckingTouchHandlerRegionsForEmptyLayerList)
+{
+    // Hit checking on an empty renderSurfaceLayerList should return a null pointer.
+    DebugScopedSetImplThread thisScopeIsOnImplThread;
+
+    std::vector<LayerImpl*> renderSurfaceLayerList;
+
+    gfx::Point testPoint(0, 0);
+    LayerImpl* resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(10, 20);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+}
+
+TEST(LayerTreeHostCommonTest, verifyHitCheckingTouchHandlerRegionsForSingleLayer)
+{
+    DebugScopedSetImplThread thisScopeIsOnImplThread;
+
+    scoped_ptr<LayerImpl> root = LayerImpl::create(12345);
+
+    WebTransformationMatrix identityMatrix;
+    Region touchHandlerRegion(gfx::Rect(10, 10, 50, 50));
+    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::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
+
+    // Sanity check the scenario we just created.
+    ASSERT_EQ(1u, renderSurfaceLayerList.size());
+    ASSERT_EQ(1u, root->renderSurface()->layerList().size());
+
+    // Hit checking for any point should return a null pointer for a layer without any touch event handler regions.
+    gfx::Point testPoint(11, 11);
+    LayerImpl* resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    root->setTouchEventHandlerRegion(touchHandlerRegion);
+    // Hit checking for a point outside the layer should return a null pointer.
+    testPoint = gfx::Point(101, 101);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(-1, -1);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Hit checking for a point inside the layer, but outside the touch handler region should return a null pointer.
+    testPoint = gfx::Point(1, 1);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(99, 99);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Hit checking for a point inside the touch event handler region should return the root layer.
+    testPoint = gfx::Point(11, 11);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(12345, resultLayer->id());
+
+    testPoint = gfx::Point(59, 59);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(12345, resultLayer->id());
+}
+
+TEST(LayerTreeHostCommonTest, verifyHitCheckingTouchHandlerRegionsForUninvertibleTransform)
+{
+    DebugScopedSetImplThread thisScopeIsOnImplThread;
+
+    scoped_ptr<LayerImpl> root = LayerImpl::create(12345);
+
+    WebTransformationMatrix uninvertibleTransform;
+    uninvertibleTransform.setM11(0);
+    uninvertibleTransform.setM22(0);
+    uninvertibleTransform.setM33(0);
+    uninvertibleTransform.setM44(0);
+    ASSERT_FALSE(uninvertibleTransform.isInvertible());
+
+    WebTransformationMatrix identityMatrix;
+    Region touchHandlerRegion(gfx::Rect(10, 10, 50, 50));
+    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);
+    root->setTouchEventHandlerRegion(touchHandlerRegion);
+
+    std::vector<LayerImpl*> renderSurfaceLayerList;
+    int dummyMaxTextureSize = 512;
+    LayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
+
+    // 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 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 testPoint(1, 1);
+    LayerImpl* resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(10, 10);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(10, 30);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(50, 50);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(67, 48);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(99, 99);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(-1, -1);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+}
+
+TEST(LayerTreeHostCommonTest, verifyHitCheckingTouchHandlerRegionsForSinglePositionedLayer)
+{
+    DebugScopedSetImplThread thisScopeIsOnImplThread;
+
+    scoped_ptr<LayerImpl> root = LayerImpl::create(12345);
+
+    WebTransformationMatrix identityMatrix;
+    Region touchHandlerRegion(gfx::Rect(10, 10, 50, 50));
+    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);
+    root->setTouchEventHandlerRegion(touchHandlerRegion);
+
+    std::vector<LayerImpl*> renderSurfaceLayerList;
+    int dummyMaxTextureSize = 512;
+    LayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
+
+    // Sanity check the scenario we just created.
+    ASSERT_EQ(1u, renderSurfaceLayerList.size());
+    ASSERT_EQ(1u, root->renderSurface()->layerList().size());
+
+    // Hit checking for a point outside the layer should return a null pointer.
+    gfx::Point testPoint(49, 49);
+    LayerImpl* resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Even though the layer has a touch handler region containing (101, 101), it should not be visible there since the root renderSurface would clamp it.
+    testPoint = gfx::Point(101, 101);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Hit checking for a point inside the layer, but outside the touch handler region should return a null pointer.
+    testPoint = gfx::Point(51, 51);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Hit checking for a point inside the touch event handler region should return the root layer.
+    testPoint = gfx::Point(61, 61);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(12345, resultLayer->id());
+
+    testPoint = gfx::Point(99, 99);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(12345, resultLayer->id());
+}
+
+TEST(LayerTreeHostCommonTest, verifyHitCheckingTouchHandlerRegionsForSingleLayerWithScaledContents)
+{
+    // 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 checking will mis-interpret the visibleContentRect
+    // as being larger than the actual bounds of the layer.
+    //
+    DebugScopedSetImplThread thisScopeIsOnImplThread;
+
+    scoped_ptr<LayerImpl> root = LayerImpl::create(1);
+
+    WebTransformationMatrix identityMatrix;
+    gfx::PointF anchor(0, 0);
+
+    setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
+
+    {
+        Region touchHandlerRegion(gfx::Rect(10, 10, 30, 30));
+        gfx::PointF position(25, 25);
+        gfx::Size bounds(50, 50);
+        scoped_ptr<LayerImpl> testLayer = LayerImpl::create(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);
+        testLayer->setTouchEventHandlerRegion(touchHandlerRegion);
+        root->addChild(testLayer.Pass());
+    }
+
+    std::vector<LayerImpl*> renderSurfaceLayerList;
+    int dummyMaxTextureSize = 512;
+    LayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
+
+    // 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 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 testPoint(76, 76);
+    LayerImpl* resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Hit checking for a point inside the layer, but outside the touch handler region should return a null pointer.
+    testPoint = gfx::Point(26, 26);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(34, 34);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(65, 65);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(74, 74);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Hit checking for a point inside the touch event handler region should return the root layer.
+    testPoint = gfx::Point(35, 35);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(12345, resultLayer->id());
+
+    testPoint = gfx::Point(64, 64);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(12345, resultLayer->id());
+}
+
+TEST(LayerTreeHostCommonTest, verifyHitCheckingTouchHandlerRegionsForSingleLayerWithDeviceScale)
+{
+    // The layer's deviceScalefactor should scale the contentRect and we should be able to hit the touch handler region
+    // by scaling the points accordingly.

[danakj, 2012/11/13 00:42:04]

This sounds like actually the opposite of what we would want/expect.

The content bounds of the layers should be scaled. But the hit testing input and
output is all in layer space. So the coordinates/bounds you would use and the
expectations here should all be the exact same as the other tests.

Different behaviour under device/page scale should indicate failure, I believe.

[Yusuf, 2012/11/13 01:17:49]

Looking at scrollBegin(), we also scale the incoming point by deviceScaleFactor.
That was mainly the reason I thought the behavior was different for
deviceScaleFactor.

Looking at calculateDrawTransformsInternal we factor in the deviceScaleFactor in
the screenSpaceTransform, but don't add it to contentsScale, which means the
first inversion will divide the input point by deviceScaleFactor. Should I be
scaling it inside pointHitsRegion instead of doing it here in the test code and
also remove the scale from layer_tree_host_impl? 

On 2012/11/13 00:42:04, danakj wrote:

[danakj, 2012/11/13 01:25:05]

The incoming point goes through these transformations in total

Viewport Space -> Device Viewport Space (This is in scrollBegin())
Device Viewport Space -> Layer Content Space (This is with screenspace transform
inverse)
Layer Content Space -> Layer Space (This is with scale by contentsScaleX and
contentsScaleY).

You should not need to do any scaling of the region. Since the deviceScaleFactor
does not affect the contentsScale, then the 2nd step above should end up
directly in the layer space, and the contentsScaleX/Y scaling should be a no-op
(they'll both be one). And then your hit test point will be in layer space, the
same as the region.

[Yusuf, 2012/11/13 01:41:39]

Then since the viewport space to deviceViewPort space conversion is taking place
in layer_tree_host_impl, should I just move this one test to that level as well
to avoid scaling these points in the test? 

Sorry, I think I am still having trouble seeing how to make the test work in
layer_tree_host_common without scaling the input points. Should I move the
viewport->device viewport conversion to later_tree_host_common as well somehow?
On 2012/11/13 01:25:05, danakj wrote:

[danakj, 2012/11/13 01:54:00]

Ahhh. I see. I forgot this was not going through LayerTreeHostImpl. For
scrolling we have hit test tests here, but also some tests in
layer_tree_host_impl_unittest to cover the scrollBegin method doing the right
thing.

It would be nice to have a test like
LayerTreeHostImplTest.nonFastScrollableRegionBasic to handle device scale. In
fact, I see now we don't even have such a test for scrolling though (only for
contents scale).

So you're absolutely right, the input touch points in here should all be scaled
up by deviceScaleFactor (but layer position/bounds shouldn't still).

I'll make a bug to add deviceScale tests for both this and scrolling to
LayerTreeHostImplTests.

+    DebugScopedSetImplThread thisScopeIsOnImplThread;
+
+    scoped_ptr<LayerImpl> root = LayerImpl::create(1);
+
+    WebTransformationMatrix identityMatrix;
+    gfx::PointF anchor(0, 0);
+    // Set the bounds of the root layer big enough to fit the child when scaled.
+    setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(250, 250), false);

[danakj, 2012/11/13 00:50:43]

Don't change the bounds of the root. Layer space should all be the same
regardless of device/page scale.

[Yusuf, 2012/11/13 01:17:49]

Done.

+
+    {
+        Region touchHandlerRegion(gfx::Rect(10, 10, 30, 30));
+        gfx::PointF position(25, 25);
+        gfx::Size bounds(50, 50);
+        scoped_ptr<LayerImpl> testLayer = LayerImpl::create(12345);
+        setLayerPropertiesForTesting(testLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
+
+        testLayer->setDrawsContent(true);
+        testLayer->setTouchEventHandlerRegion(touchHandlerRegion);
+        root->addChild(testLayer.Pass());
+    }
+
+    std::vector<LayerImpl*> renderSurfaceLayerList;
+    int dummyMaxTextureSize = 512;
+    float deviceScaleFactor = 3.0f;
+    float pageScaleFactor = 5.0f; // pageScaleFactor shouldn't factor into this for LayerImpl.

[danakj, 2012/11/13 00:50:43]

I'm not sure what you mean by this comment here. The pageScaleFactor should
change the contentsBounds for the layers. But that should not change the layer
space, so it shouldn't affect the output of the hit test methods.

What did you observe that led to this comment?

[Yusuf, 2012/11/13 00:57:36]

I may be misinterpreting the code I think, but calculateDrawwTransform calls
calculateDrawTransformsInternal and in that, the only place we use
pageScalefactor is updateLayerContentsScale. And in the implementation
corresponding to LayerImpl* it says "There is no contentsScale on impl thread."



On 2012/11/13 00:50:43, danakj wrote:

[danakj, 2012/11/13 01:07:45]

Oh! Okay, right. Since there's no main thread to set the contentsScale it's more
or less a no-op for now. In the future, when the compositor is applying the
pageScaleFactor, then it will be less of a no-op and more like
deviceScaleFactor. So this test should continue to pass when that change
happens.

[danakj, 2012/11/13 01:12:39]

Actually, sorry, I confused myself. The pageScaleFactor is applied, via the
setImplTransform() method on the rootScrollLayer.

In this case, before calling calcDraw, can you do:

WebTransformationMatrix pageScaleTransform;
pageScaleTransform.scale(pageScaleFactor);
rootLayer->setImplTransform(pageScaleTransform);

That will get the contents of both layers scaling by the page scale factor.
Again, though, it should not affect anything done in layer space.

+    LayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), deviceScaleFactor, pageScaleFactor, 0, dummyMaxTextureSize, renderSurfaceLayerList);

[danakj, 2012/11/13 00:50:43]

The 2nd argument is the deviceViewportSize, ie the viewport size in physical
pixels. This should be

gfx::ToEnclosingRect(gfx::ScaleRect(root->bounds(), deviceScaleFactor))

[Yusuf, 2012/11/13 01:17:49]

Using gfx::ToCeiledSize(root->bounds().Scale(deviceScaleFactor)) as this
parameter is gfx::Size

On 2012/11/13 00:50:43, danakj wrote:

+
+    // Sanity check the scenario we just created.
+    // The visibleContentRect for testLayer is actually 100x100, even though its layout size is 50x50, positioned at 25x25.

[danakj, 2012/11/13 00:50:43]

I don't see a check related to this comment.

[Yusuf, 2012/11/13 01:17:49]

Sorry meant to swap this check with the one about VisibleContentrect, but left
the comment here. It is removed now.

+    LayerImpl* testLayer = root->children()[0];
+    ASSERT_EQ(1u, renderSurfaceLayerList.size());
+    ASSERT_EQ(1u, root->renderSurface()->layerList().size());
+
+    // Check whether the child layer fits into the root after scaled.
+    EXPECT_RECT_EQ(gfx::Rect(gfx::Point(), gfx::Size(50, 50)), testLayer->visibleContentRect());

[danakj, 2012/11/13 00:50:43]

The root layer is 250,250 now, so this seems off? You're checking if the
testLayer was clipped, right? So:

EXPECT_EQ(gfx::Rect(testLayer->contentBounds()),
testLayer->VisibleContentRect()); ?

[Yusuf, 2012/11/13 01:17:49]

Done.

+
+    // 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 testPoint(76, 76);
+    testPoint = testPoint.Scale(deviceScaleFactor);
+    LayerImpl* resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Hit checking for a point inside the layer, but outside the touch handler region should return a null pointer.
+    testPoint = gfx::Point(26, 26);
+    testPoint = testPoint.Scale(deviceScaleFactor);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(34, 34);
+    testPoint = testPoint.Scale(deviceScaleFactor);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(65, 65);
+    testPoint = testPoint.Scale(deviceScaleFactor);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(74, 74);
+    testPoint = testPoint.Scale(deviceScaleFactor);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Hit checking for a point inside the touch event handler region should return the root layer.
+    testPoint = gfx::Point(35, 35);
+    testPoint = testPoint.Scale(deviceScaleFactor);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(12345, resultLayer->id());
+
+    testPoint = gfx::Point(64, 64);
+    testPoint = testPoint.Scale(deviceScaleFactor);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(12345, resultLayer->id());
+}
+
+TEST(LayerTreeHostCommonTest, verifyHitCheckingTouchHandlerRegionsForSimpleClippedLayer)
+{
+    // 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.
+    DebugScopedSetImplThread thisScopeIsOnImplThread;
+
+    WebTransformationMatrix identityMatrix;
+    gfx::PointF anchor(0, 0);
+
+    scoped_ptr<LayerImpl> root = LayerImpl::create(1);
+    setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
+
+    {
+        scoped_ptr<LayerImpl> clippingLayer = LayerImpl::create(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(456);
+        Region touchHandlerRegion(gfx::Rect(10, 10, 50, 50));
+        position = gfx::PointF(-50, -50);
+        bounds = gfx::Size(300, 300);
+        setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
+        child->setDrawsContent(true);
+        child->setTouchEventHandlerRegion(touchHandlerRegion);
+        clippingLayer->addChild(child.Pass());
+        root->addChild(clippingLayer.Pass());
+    }
+
+    std::vector<LayerImpl*> renderSurfaceLayerList;
+    int dummyMaxTextureSize = 512;
+    LayerTreeHostCommon::calculateDrawTransforms(root.get(), root->bounds(), 1, 1, 0, dummyMaxTextureSize, renderSurfaceLayerList);
+
+    // 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 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 testPoint(24, 24);
+    LayerImpl* resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Hit checking for a point inside the layer, but outside the touch handler region should return a null pointer.
+    testPoint = gfx::Point(35, 35);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    testPoint = gfx::Point(74, 74);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    EXPECT_FALSE(resultLayer);
+
+    // Hit checking for a point inside the touch event handler region should return the root layer.
+    testPoint = gfx::Point(25, 25);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(456, resultLayer->id());
+
+    testPoint = gfx::Point(34, 34);
+    resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
+    ASSERT_TRUE(resultLayer);
+    EXPECT_EQ(456, resultLayer->id());
+}
+
 class NoScaleContentLayer : public ContentLayer
 {
 public:
     static scoped_refptr<NoScaleContentLayer> create(ContentLayerClient* client) { return make_scoped_refptr(new NoScaleContentLayer(client)); }
 
     virtual gfx::Size contentBounds() const OVERRIDE { return bounds(); }
     virtual float contentsScaleX() const OVERRIDE { return 1.0; }
     virtual float contentsScaleY() const OVERRIDE { return 1.0; }
 
 protected:
@@ skipping 563 matching lines @@
     int nonexistentId = -1;
     EXPECT_EQ(root, LayerTreeHostCommon::findLayerInSubtree(root.get(), root->id()));
     EXPECT_EQ(child, LayerTreeHostCommon::findLayerInSubtree(root.get(), child->id()));
     EXPECT_EQ(grandChild, LayerTreeHostCommon::findLayerInSubtree(root.get(), grandChild->id()));
     EXPECT_EQ(maskLayer, LayerTreeHostCommon::findLayerInSubtree(root.get(), maskLayer->id()));
     EXPECT_EQ(replicaLayer, LayerTreeHostCommon::findLayerInSubtree(root.get(), replicaLayer->id()));
     EXPECT_EQ(0, LayerTreeHostCommon::findLayerInSubtree(root.get(), nonexistentId));
 }
 
 }  // anonymous namespace