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();
+}
+
 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;
 

[danakj, 2013/10/07 16:29:13]

Can you add skipping layers that have draw-opacity of 0 here since they will no
longer be skipped entirely by subtree? You'll have to pass in the computed
draw-opacity similar to layer_is_visible.

Can you add a test with a 0 opacity layer with 2 children, one with an event
handler. The layer and the non-event handler should not appear in the RSLL. The
event handler should.

[sadrul, 2013/10/07 17:16:49]

I have updated the code here to look at layer->draw_opacity() (and
layer->draw_opacity_is_animation()).

I am not sure what you mean by passing in the computed draw-opacity. Do you mean
|data_for_children| should carry this information, e.g.:

  data_for_children.computed_opacity = data_from_ancestor.computed_opacity *
layer->opacity();

?
Done.

[danakj, 2013/10/07 17:37:35]

I meant that this function doesn't use draw properties directly right now, which
lets it be ignorant of the order things are computed and assigned to draw
properties. It'd be nice to just pass the |accumulated_draw_opacity| to this
function as an argument instead.

[sadrul, 2013/10/07 18:37:24]

Ah, I see. Done. (needed both |accumulated_draw_opacity| and
|animating_opacity_to_target| to be passed in)

But quickly reverted this change, since it looks like |accumulated_draw_opacity|
is not always the same as layer->draw_opacity() (e.g. when
|render_to_separate_surface| is set). Should I just pass in
layer->draw_opacity() and layer->draw_opacity_is_animating() as parameters to
this function, or keep using these draw_properties from within this function?

[danakj, 2013/10/07 19:02:36]

Oh right, inside a surface the opacity goes back to 1.. since the surface itself
will apply the opacity < 1 effect.

We don't actually track opacity across surfaces at all, since we assumed you'd
early out. I think you'll need to store some extra bit to pass down the tree
saying that this is 0 opacity. This is not unlike what enne@ suggested as well.

   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() &&
+         !layer->draw_properties().layer_or_descendant_has_event_handler;
 }
 
 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() &&
+         !layer->draw_properties().layer_or_descendant_has_event_handler;
 }
 
 // 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 488 matching lines @@
     render_surface_layer_list->back()->ClearRenderSurface();
     render_surface_layer_list->pop_back();
   }
   DCHECK_EQ(render_surface_layer_list->back(), layer_to_remove);
   render_surface_layer_list->pop_back();
   layer_to_remove->ClearRenderSurface();
 }
 
 struct PreCalculateMetaInformationRecursiveData {
   bool layer_or_descendant_has_copy_request;
+  bool layer_or_descendant_has_event_handler;
   int num_unclipped_descendants;
 
   PreCalculateMetaInformationRecursiveData()
       : layer_or_descendant_has_copy_request(false),
+        layer_or_descendant_has_event_handler(false),
         num_unclipped_descendants(0) {}
 
   void Merge(const PreCalculateMetaInformationRecursiveData& data) {
     layer_or_descendant_has_copy_request |=
         data.layer_or_descendant_has_copy_request;
+    layer_or_descendant_has_event_handler |=
+        data.layer_or_descendant_has_event_handler;
     num_unclipped_descendants +=
         data.num_unclipped_descendants;
   }
 };
 
 // Recursively walks the layer tree to compute any information that is needed
 // before doing the main recursion.
 template <typename LayerType>
 static void PreCalculateMetaInformation(
     LayerType* layer,
@@ skipping 41 matching lines @@
 
   if (layer->clip_children()) {
     int num_clip_children = layer->clip_children()->size();
     DCHECK_GE(recursive_data->num_unclipped_descendants, num_clip_children);
     recursive_data->num_unclipped_descendants -= num_clip_children;
   }
 
   if (layer->HasCopyRequest())
     recursive_data->layer_or_descendant_has_copy_request = true;
 
+  if (LayerCanAcceptInput(layer))
+    recursive_data->layer_or_descendant_has_event_handler = true;
+
   layer->draw_properties().num_descendants_that_draw_content =
       num_descendants_that_draw_content;
   layer->draw_properties().num_unclipped_descendants =
       recursive_data->num_unclipped_descendants;
   layer->draw_properties().descendants_can_clip_selves =
       descendants_can_clip_selves;
   layer->draw_properties().layer_or_descendant_has_copy_request =
       recursive_data->layer_or_descendant_has_copy_request;
+  layer->draw_properties().layer_or_descendant_has_event_handler =
+      recursive_data->layer_or_descendant_has_event_handler;
 }
 
 static void RoundTranslationComponents(gfx::Transform* transform) {
   transform->matrix().set(0, 3, MathUtil::Round(transform->matrix().get(0, 3)));
   transform->matrix().set(1, 3, MathUtil::Round(transform->matrix().get(1, 3)));
 }
 
 template <typename LayerType>
 struct SubtreeGlobals {
   LayerSorter* layer_sorter;
@@ skipping 1141 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