cc: Don't consider HUD layer for touches

cc/layer_tree_host_common.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_common.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "cc/layer.h"
@@ skipping 1053 matching lines @@
         dummyLayerList, &layerSorter, maxTextureSize,
         deviceScaleFactor, pageScaleFactor, canUseLCDText, totalDrawableContentRect,
         updateTilePriorities);
 
     // The dummy layer list should not have been used.
     DCHECK(dummyLayerList.size() == 0);
     // A root layer renderSurface should always exist after calculateDrawProperties.
     DCHECK(rootLayer->renderSurface());
 }
 
-static bool pointHitsRect(const gfx::PointF& screenSpacePoint, const gfx::Transform& localSpaceToScreenSpaceTransform, gfx::RectF localSpaceRect)
-{
-    // If the transform is not invertible, then assume that this point doesn't hit this rect.
-    gfx::Transform inverseLocalSpaceToScreenSpace(gfx::Transform::kSkipInitialization);
-    if (!localSpaceToScreenSpaceTransform.GetInverse(&inverseLocalSpaceToScreenSpace))
-        return false;
-
-    // Transform the hit test point from screen space to the local space of the given rect.
-    bool clipped = false;
-    gfx::PointF hitTestPointInLocalSpace = MathUtil::projectPoint(inverseLocalSpaceToScreenSpace, screenSpacePoint, clipped);
-
-    // If projectPoint could not project to a valid value, then we assume that this point doesn't hit this rect.
-    if (clipped)
-        return false;
-
-    return localSpaceRect.Contains(hitTestPointInLocalSpace);
-}
-
 static bool pointHitsRegion(gfx::PointF screenSpacePoint, const gfx::Transform& screenSpaceTransform, const Region& layerSpaceRegion, float layerContentScaleX, float layerContentScaleY)
 {
     // If the transform is not invertible, then assume that this point doesn't hit this region.
     gfx::Transform inverseScreenSpaceTransform(gfx::Transform::kSkipInitialization);
     if (!screenSpaceTransform.GetInverse(&inverseScreenSpaceTransform))
         return false;
 
     // Transform the hit test point from screen space to the local space of the given region.
     bool clipped = false;
     gfx::PointF hitTestPointInContentSpace = MathUtil::projectPoint(inverseScreenSpaceTransform, screenSpacePoint, clipped);
     gfx::PointF hitTestPointInLayerSpace = gfx::ScalePoint(hitTestPointInContentSpace, 1 / layerContentScaleX, 1 / layerContentScaleY);
 
     // If projectPoint could not project to a valid value, then we assume that this point doesn't hit this region.
     if (clipped)
         return false;
 
     return layerSpaceRegion.Contains(gfx::ToRoundedPoint(hitTestPointInLayerSpace));
 }
 
-static bool pointIsClippedBySurfaceOrClipRect(const gfx::PointF& screenSpacePoint, LayerImpl* layer)
+bool LayerTreeHostCommon::pointIsClippedBySurfaceOrClipRect(const gfx::PointF& screenSpacePoint, LayerImpl* layer)
 {
     LayerImpl* currentLayer = layer;
 
     // Walk up the layer tree and hit-test any renderSurfaces and any layer clipRects that are active.
     while (currentLayer) {
-        if (currentLayer->renderSurface() && !pointHitsRect(screenSpacePoint, currentLayer->renderSurface()->screenSpaceTransform(), currentLayer->renderSurface()->contentRect()))
+        if (currentLayer->renderSurface() && !MathUtil::pointHitsRect(screenSpacePoint, currentLayer->renderSurface()->screenSpaceTransform(), currentLayer->renderSurface()->contentRect()))
             return true;
 
         // Note that drawableContentRects are actually in targetSurface space, so the transform we
         // have to provide is the target surface's screenSpaceTransform.
         LayerImpl* renderTarget = currentLayer->renderTarget();
-        if (layerClipsSubtree(currentLayer) && !pointHitsRect(screenSpacePoint, renderTarget->renderSurface()->screenSpaceTransform(), currentLayer->drawableContentRect()))
+        if (layerClipsSubtree(currentLayer) && !MathUtil::pointHitsRect(screenSpacePoint, renderTarget->renderSurface()->screenSpaceTransform(), currentLayer->drawableContentRect()))
             return true;
 
         currentLayer = currentLayer->parent();
     }
 
     // If we have finished walking all ancestors without having already exited, then the point is not clipped by any ancestors.
     return false;
 }
 
-LayerImpl* LayerTreeHostCommon::findLayerThatIsHitByPoint(const gfx::PointF& screenSpacePoint, const std::vector<LayerImpl*>& renderSurfaceLayerList)
-{
-    LayerImpl* foundLayer = 0;
-
-    typedef LayerIterator<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl, LayerIteratorActions::FrontToBack> LayerIteratorType;
-    LayerIteratorType end = LayerIteratorType::end(&renderSurfaceLayerList);
-
-    for (LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) {
-        // We don't want to consider renderSurfaces for hit testing.
-        if (!it.representsItself())
-            continue;
-
-        LayerImpl* currentLayer = (*it);
-
-        gfx::RectF contentRect(gfx::PointF(), currentLayer->contentBounds());
-        if (!pointHitsRect(screenSpacePoint, currentLayer->screenSpaceTransform(), contentRect))
-            continue;
-
-        // At this point, we think the point does hit the layer, but we need to walk up
-        // the parents to ensure that the layer was not clipped in such a way that the
-        // hit point actually should not hit the layer.
-        if (pointIsClippedBySurfaceOrClipRect(screenSpacePoint, currentLayer))
-            continue;
-
-        foundLayer = currentLayer;
-        break;
-    }
-
-    // This can potentially return 0, which means the screenSpacePoint did not successfully hit test any layers, not even the root layer.
-    return foundLayer;
-}
-
 LayerImpl* LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(const gfx::PointF& screenSpacePoint, const std::vector<LayerImpl*>& renderSurfaceLayerList)
 {
     LayerImpl* foundLayer = 0;
 
     typedef LayerIterator<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl, LayerIteratorActions::FrontToBack> LayerIteratorType;
     LayerIteratorType end = LayerIteratorType::end(&renderSurfaceLayerList);
 
     for (LayerIteratorType it = LayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) {
         // We don't want to consider renderSurfaces for hit testing.
         if (!it.representsItself())
@@ skipping 21 matching lines @@
 
   // At this point, we think the point does hit the touch event handler region on the layer, but we need to walk up
   // the parents to ensure that the layer was not clipped in such a way that the
   // hit point actually should not hit the layer.
   if (pointIsClippedBySurfaceOrClipRect(screenSpacePoint, layerImpl))
      return false;
 
   return true;
 }
 }  // namespace cc