cc: Fix hit-testing in zero-opacity layers.

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 45 matching lines @@
 static gfx::Vector2dF GetEffectiveTotalScrollOffset(LayerType* layer) {
   gfx::Vector2dF offset = layer->TotalScrollOffset();
   // The scroll parent's total scroll offset (scroll offset + scroll delta)
   // can't be used because its scroll offset has already been applied to the
   // scroll children's positions by the main thread layer positioning code.
   if (layer->scroll_parent())
     offset += layer->scroll_parent()->ScrollDelta();
   return offset;
 }
 
+template <typename LayerType>
+static inline bool LayerCanAcceptInput(LayerType* layer) {
+  return !layer->touch_event_handler_region().IsEmpty() ||
+         layer->have_wheel_event_handlers();
+}
+
+template <typename LayerType>
+static bool LayerSubtreeCanAcceptInput(LayerType* layer) {

[sadrul, 2013/10/05 07:57:32]

This should be called only for subtrees where the root has zero opacity. So this
should be called relatively rarely, and so should not have a significant
performance impact. But to be on the safe side, should we add a max-depth for
the recursion, and just assume the subtree can accept input events if the
recursion exceeds the depth?

[enne (OOO), 2013/10/05 16:40:18]

What about setting a flag in the prerecursion, like
layer_or_descendant_has_copy_request?

[sadrul, 2013/10/05 21:09:05]

Oh, cool. That looks much better. Done.

+  if (LayerCanAcceptInput(layer))
+    return true;
+  for (size_t i = 0; i < layer->children().size(); ++i) {
+    LayerType* child =
+        LayerTreeHostCommon::get_child_as_raw_ptr(layer->children(), i);
+    if (LayerSubtreeCanAcceptInput(child))
+      return true;
+  }
+  return false;
+}
+
 inline gfx::Rect CalculateVisibleRectWithCachedLayerRect(
     gfx::Rect target_surface_rect,
     gfx::Rect layer_bound_rect,
     gfx::Rect layer_rect_in_target_space,
     const gfx::Transform& transform) {
   if (layer_rect_in_target_space.IsEmpty())
     return gfx::Rect();
 
   // Is this layer fully contained within the target surface?
   if (target_surface_rect.Contains(layer_rect_in_target_space))
@@ skipping 371 matching lines @@
 
   // The layer should not be drawn if (1) it is not double-sided and (2) the
   // back of the layer is known to be facing the screen.
   if (!backface_test_layer->double_sided() &&
       TransformToScreenIsKnown(backface_test_layer) &&
       IsLayerBackFaceVisible(backface_test_layer))
     return true;
 
   // The layer is visible to events.  If it's subject to hit testing, then
   // we can't skip it.
-  bool can_accept_input = !layer->touch_event_handler_region().IsEmpty() ||
-      layer->have_wheel_event_handlers();
-  if (!layer->DrawsContent() && !can_accept_input)
+  if (!layer->DrawsContent() && !LayerCanAcceptInput(layer))
     return true;
 
   return false;
 }
 
 static inline bool SubtreeShouldBeSkipped(LayerImpl* layer,
                                           bool layer_is_visible) {
   // When we need to do a readback/copy of a layer's output, we can not skip
   // it or any of its ancestors.
   if (layer->draw_properties().layer_or_descendant_has_copy_request)
     return false;
 
   // If the layer is not visible, then skip it and its subtree.
   if (!layer_is_visible)
     return true;
 
   // If layer is on the pending tree and opacity is being animated then
   // this subtree can't be skipped as we need to create, prioritize and
   // include tiles for this layer when deciding if tree can be activated.
   if (layer->layer_tree_impl()->IsPendingTree() && layer->OpacityIsAnimating())
     return false;
 
   // The opacity of a layer always applies to its children (either implicitly
   // via a render surface or explicitly if the parent preserves 3D), so the
-  // entire subtree can be skipped if this layer is fully transparent.
-  // TODO(sad): Don't skip layers used for hit testing crbug.com/295295.
-  return !layer->opacity();
+  // entire subtree can be skipped if this layer is fully transparent, and none
+  // of layers in the subtree has event handlers.
+  return !layer->opacity() && !LayerSubtreeCanAcceptInput(layer);
 }
 
 static inline bool SubtreeShouldBeSkipped(Layer* layer,
                                           bool layer_is_visible) {
   // When we need to do a readback/copy of a layer's output, we can not skip
   // it or any of its ancestors.
   if (layer->draw_properties().layer_or_descendant_has_copy_request)
     return false;
 
   // If the layer is not visible, then skip it and its subtree.
   if (!layer_is_visible)
     return true;
 
   // If the opacity is being animated then the opacity on the main thread is
   // unreliable (since the impl thread may be using a different opacity), so it
   // should not be trusted.
   // In particular, it should not cause the subtree to be skipped.
   // Similarly, for layers that might animate opacity using an impl-only
   // animation, their subtree should also not be skipped.
-  // TODO(sad): Don't skip layers used for hit testing crbug.com/295295.
   return !layer->opacity() && !layer->OpacityIsAnimating() &&
-         !layer->OpacityCanAnimateOnImplThread();
+         !layer->OpacityCanAnimateOnImplThread() &&
+         !LayerSubtreeCanAcceptInput(layer);
 }
 
 // Called on each layer that could be drawn after all information from
 // CalcDrawProperties has been updated on that layer.  May have some false
 // positives (e.g. layers get this called on them but don't actually get drawn).
 static inline void UpdateTilePrioritiesForLayer(LayerImpl* layer) {
   layer->UpdateTilePriorities();
 
   // Mask layers don't get this call, so explicitly update them so they can
   // kick off tile rasterization.
@@ skipping 1727 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(screen_space_point, layer_impl))
     return false;
 
   return true;
 }
 }  // namespace cc