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 332 matching lines @@
 }
 
 static inline bool TransformToScreenIsKnown(LayerImpl* layer) { return true; }
 
 static inline bool TransformToScreenIsKnown(Layer* layer) {
   return !layer->screen_space_transform_is_animating();
 }
 
 template <typename LayerType>
 static bool LayerShouldBeSkipped(LayerType* layer,
-                                 bool layer_is_visible) {
+                                 bool layer_is_visible,
+                                 bool visit_for_event_handler_only) {

[danakj, 2013/10/08 18:32:32]

how about bool "layer_has_zero_opacity"? only is a bit of a loaded term here,
you might be here for event handlers and also for copy requests.

+  // If an ancestor node was going to be skipped, but wasn't only because it had
+  // event handlers in the subtree, and there are not event handlers in the
+  // subtree rooted at |layer|, then skip this layer.
+  if (visit_for_event_handler_only &&

[danakj, 2013/10/08 18:32:32]

Move this down below the big intro comment, and update the intro comment to
accomodate this.

+      !layer->draw_properties().layer_or_descendant_has_event_handler) {
+    return true;
+  }
+
   // Layers can be skipped if any of these conditions are met.
   //   - is not visible due to it or one of its ancestors being hidden.
   //   - has empty bounds
   //   - the layer is not double-sided, but its back face is visible.
   //   - is transparent
   //   - does not draw content and does not participate in hit testing.
   //
   // Some additional conditions need to be computed at a later point after the
   // recursion is finished.
   //   - the intersection of render_surface content and layer clip_rect is empty
   //   - the visible_content_rect is empty
   //
   // Note, if the layer should not have been drawn due to being fully

[danakj, 2013/10/08 18:32:32]

This comment is wrong then, and needs updating.

   // transparent, we would have skipped the entire subtree and never made it
   // into this function, so it is safe to omit this check here.
 
   if (!layer_is_visible)
     return true;
 
   if (layer->bounds().IsEmpty())
     return true;
 
   LayerType* backface_test_layer = layer;
   if (layer->use_parent_backface_visibility()) {
     DCHECK(layer->parent());
     DCHECK(!layer->parent()->use_parent_backface_visibility());
     backface_test_layer = layer->parent();
   }
 
   // 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)
+  // A layer cannot be skipped if it is subject to hit-testing.
+  if (LayerCanAcceptInput(layer))
+    return false;
+
+  if (!layer->DrawsContent())
+    return true;
+
+  if (!layer->draw_opacity() && !layer->draw_opacity_is_animating())

[danakj, 2013/10/08 18:32:32]

Animating only matters on the main thread. On the impl thread we should ignore
it. This needs to be covered by a test.

If the layer owns a surface, it'll have draw opacity of 1 and I believe that
visit_for_event_handler_only will be false. But it should be skipped since its
surface has opacity 0. This needs to be covered by a test.

     return true;
 
   return false;
 }
 
 static inline bool SubtreeShouldBeSkipped(LayerImpl* layer,
-                                          bool layer_is_visible) {
+                                          bool layer_is_visible,
+                                          bool *visit_for_event_handler_only) {
+  if (*visit_for_event_handler_only &&
+      !layer->draw_properties().layer_or_descendant_has_event_handler) {
+    return true;
+  }
+
   // 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;
 
+  bool skip_if_no_event_handler = !layer->opacity();
+
+  // If the layer (or any of its descendant) is subject to hit-testing, then the
+  // subtree cannot be skipped.
+  if (layer->draw_properties().layer_or_descendant_has_event_handler) {
+    if (skip_if_no_event_handler)
+      *visit_for_event_handler_only = true;
+    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();
+  return skip_if_no_event_handler;
 }
 
 static inline bool SubtreeShouldBeSkipped(Layer* layer,
-                                          bool layer_is_visible) {
+                                          bool layer_is_visible,
+                                          bool* visit_for_event_handler_only) {
+  if (*visit_for_event_handler_only &&
+      !layer->draw_properties().layer_or_descendant_has_event_handler) {
+    return true;
+  }
+
   // 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();
+  bool skip_if_no_event_handler =
+      !layer->opacity() && !layer->OpacityIsAnimating() &&
+      !layer->OpacityCanAnimateOnImplThread();
+
+  // If the layer (or any of its descendant) is subject to hit-testing, then the
+  // subtree cannot be skipped.
+  if (layer->draw_properties().layer_or_descendant_has_event_handler) {
+    if (skip_if_no_event_handler)
+      *visit_for_event_handler_only = true;
+    return false;
+  }
+
+  return skip_if_no_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 35 matching lines @@
   // this value redundantly for each child layer, it is computed only once
   // while dealing with the parent layer, and then this precomputed value is
   // passed down the recursion to the children that actually use it.
   gfx::Rect clip_rect_of_target_surface_in_target_space;
 
   bool ancestor_clips_subtree;
   RenderSurfaceType* nearest_ancestor_surface_that_moves_pixels;
   bool in_subtree_of_page_scale_application_layer;
   bool subtree_can_use_lcd_text;
   bool subtree_is_visible_from_ancestor;
+
+  bool visit_for_event_handler_only;
 };
 
 // Recursively walks the layer tree starting at the given node and computes all
 // the necessary transformations, clip rects, render surfaces, etc.
 template <typename LayerType,
           typename LayerListType,
           typename RenderSurfaceType>
 static void CalculateDrawPropertiesInternal(
     LayerType* layer,
     const SubtreeGlobals<LayerType>& globals,
@@ skipping 139 matching lines @@
 
   // Layers with a copy request are always visible, as well as un-hiding their
   // subtree. Otherise, layers that are marked as hidden will hide themselves
   // and their subtree.
   bool layer_is_visible =
       data_from_ancestor.subtree_is_visible_from_ancestor &&
       !layer->hide_layer_and_subtree();
   if (layer->HasCopyRequest())
     layer_is_visible = true;
 
+  bool visit_for_event_handler_only =
+      data_from_ancestor.visit_for_event_handler_only;
   // The root layer cannot skip CalcDrawProperties.
-  if (!IsRootLayer(layer) && SubtreeShouldBeSkipped(layer, layer_is_visible)) {
+  if (!IsRootLayer(layer) &&
+      SubtreeShouldBeSkipped(layer, layer_is_visible,
+                             &visit_for_event_handler_only)) {
     if (layer->render_surface())
       layer->ClearRenderSurface();
     return;
   }
+  data_for_children.visit_for_event_handler_only = visit_for_event_handler_only;
 
   // We need to circumvent the normal recursive flow of information for clip
   // children (they don't inherit their direct ancestor's clip information).
   // This is unfortunate, and would be unnecessary if we were to formally
   // separate the clipping hierarchy from the layer hierarchy.
   bool ancestor_clips_subtree = data_from_ancestor.ancestor_clips_subtree;
   gfx::Rect ancestor_clip_rect_in_target_space =
       data_from_ancestor.clip_rect_in_target_space;
 
   // Update our clipping state. If we have a clip parent we will need to pull
@@ skipping 397 matching lines @@
   }
 
   LayerListType& descendants =
       (layer->render_surface() ? layer->render_surface()->layer_list()
                                : *layer_list);
 
   // Any layers that are appended after this point are in the layer's subtree
   // and should be included in the sorting process.
   size_t sorting_start_index = descendants.size();
 
-  if (!LayerShouldBeSkipped(layer, layer_is_visible))
+  if (!LayerShouldBeSkipped(layer, layer_is_visible,
+                            data_from_ancestor.visit_for_event_handler_only))
     descendants.push_back(layer);
 
   if (!layer->children().empty()) {
     if (layer == globals.page_scale_application_layer) {
       data_for_children.parent_matrix.Scale(
           globals.page_scale_factor,
           globals.page_scale_factor);
       data_for_children.in_subtree_of_page_scale_application_layer = true;
     }
 
@@ skipping 76 matching lines @@
 
   // Compute the layer's drawable content rect (the rect is in target surface
   // space).
   layer_draw_properties.drawable_content_rect = rect_in_target_space;
   if (layer_or_ancestor_clips_descendants) {
     layer_draw_properties.drawable_content_rect.
         Intersect(clip_rect_in_target_space);
   }
 
   // Compute the layer's visible content rect (the rect is in content space).
-  layer_draw_properties.visible_content_rect = CalculateVisibleContentRect(
+  layer_draw_properties.visible_content_rect =

[danakj, 2013/10/08 18:32:32]

Leave this rect alone. If the layer has 0 opacity but is going to animate to be
visible, we'd like to not destroy our chances of knowing what to raster.

+      visit_for_event_handler_only ? gfx::Rect() : CalculateVisibleContentRect(
       layer, clip_rect_of_target_surface_in_target_space, rect_in_target_space);
 
   // Compute the remaining properties for the render surface, if the layer has
   // one.
   if (IsRootLayer(layer)) {
     // The root layer's surface's content_rect is always the entire viewport.
     DCHECK(layer->render_surface());
     layer->render_surface()->SetContentRect(
         ancestor_clip_rect_in_target_space);
   } else if (layer->render_surface() && !IsRootLayer(layer)) {
@@ skipping 135 matching lines @@
   data_for_recursion.scroll_compensation_matrix = identity_matrix;
   data_for_recursion.fixed_container = inputs->root_layer;
   data_for_recursion.clip_rect_in_target_space = device_viewport_rect;
   data_for_recursion.clip_rect_of_target_surface_in_target_space =
       device_viewport_rect;
   data_for_recursion.ancestor_clips_subtree = true;
   data_for_recursion.nearest_ancestor_surface_that_moves_pixels = NULL;
   data_for_recursion.in_subtree_of_page_scale_application_layer = false;
   data_for_recursion.subtree_can_use_lcd_text = inputs->can_use_lcd_text;
   data_for_recursion.subtree_is_visible_from_ancestor = true;
+  data_for_recursion.visit_for_event_handler_only = false;
 
   PreCalculateMetaInformationRecursiveData recursive_data;
   PreCalculateMetaInformation(inputs->root_layer, &recursive_data);
   std::vector<AccumulatedSurfaceState<Layer> > accumulated_surface_state;
   CalculateDrawPropertiesInternal<Layer, RenderSurfaceLayerList, RenderSurface>(
       inputs->root_layer,
       globals,
       data_for_recursion,
       inputs->render_surface_layer_list,
       &dummy_layer_list,
@@ skipping 39 matching lines @@
   data_for_recursion.scroll_compensation_matrix = identity_matrix;
   data_for_recursion.fixed_container = inputs->root_layer;
   data_for_recursion.clip_rect_in_target_space = device_viewport_rect;
   data_for_recursion.clip_rect_of_target_surface_in_target_space =
       device_viewport_rect;
   data_for_recursion.ancestor_clips_subtree = true;
   data_for_recursion.nearest_ancestor_surface_that_moves_pixels = NULL;
   data_for_recursion.in_subtree_of_page_scale_application_layer = false;
   data_for_recursion.subtree_can_use_lcd_text = inputs->can_use_lcd_text;
   data_for_recursion.subtree_is_visible_from_ancestor = true;
+  data_for_recursion.visit_for_event_handler_only = false;
 
   PreCalculateMetaInformationRecursiveData recursive_data;
   PreCalculateMetaInformation(inputs->root_layer, &recursive_data);
   std::vector<AccumulatedSurfaceState<LayerImpl> >
       accumulated_surface_state;
   CalculateDrawPropertiesInternal<LayerImpl, LayerImplList, RenderSurfaceImpl>(
       inputs->root_layer,
       globals,
       data_for_recursion,
       inputs->render_surface_layer_list,
@@ skipping 192 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