Relax touch hit testing in CC to look at all layers under a point

cc/trees/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/trees/layer_tree_host_common.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 2508 matching lines @@
 
     found_layer = current_layer;
     break;
   }
 
   // This can potentially return NULL, which means the screen_space_point did
   // not successfully hit test any layers, not even the root layer.
   return found_layer;
 }
 
-// This may be generalized in the future, but we know at the very least that
-// hits cannot pass through scrolling nor opaque layers.
-static bool OpaqueToHitTesting(const LayerImpl* layer) {
-  return layer->scrollable() || layer->contents_opaque();
-}
-
 LayerImpl* LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
     const gfx::PointF& screen_space_point,
     const LayerImplList& render_surface_layer_list) {
   typedef LayerIterator<LayerImpl> LayerIteratorType;
   LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list);
   for (LayerIteratorType it =
            LayerIteratorType::Begin(&render_surface_layer_list);
        it != end;
        ++it) {
     // We don't want to consider render_surfaces for hit testing.
     if (!it.represents_itself())
       continue;
 
     LayerImpl* current_layer = (*it);
     if (!PointHitsLayer(current_layer, screen_space_point))
       continue;
 
     if (LayerTreeHostCommon::LayerHasTouchEventHandlersAt(screen_space_point,
                                                           current_layer))
       return current_layer;
 
-    if (OpaqueToHitTesting(current_layer))
-      break;
+    // Note that we could stop searching if we hit a layer we know to be
+    // opaque to hit-testing, but knowing that reliably is tricky (eg. due to
+    // CSS pointer-events: none).  Also blink has an optimization for the
+    // common case of an entire document having handlers where it doesn't
+    // report any rects for child layers (since it knows they can't exceed
+    // the document bounds).
   }
   return NULL;
 }
 
 bool LayerTreeHostCommon::LayerHasTouchEventHandlersAt(
     const gfx::PointF& screen_space_point,
     LayerImpl* layer_impl) {
   if (layer_impl->touch_event_handler_region().IsEmpty())
     return false;
 
   if (!PointHitsRegion(screen_space_point,
                        layer_impl->screen_space_transform(),
                        layer_impl->touch_event_handler_region(),
                        layer_impl->contents_scale_x(),
                        layer_impl->contents_scale_y()))
     return false;
 
   // 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(screen_space_point, layer_impl))
     return false;
 
   return true;
 }
 }  // namespace cc