cc:: Use clip tree instead of layer tree during hit testing

cc/trees/layer_tree_impl.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_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 22 matching lines @@
 #include "cc/layers/scrollbar_layer_impl_base.h"
 #include "cc/resources/ui_resource_request.h"
 #include "cc/trees/draw_property_utils.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/occlusion_tracker.h"
 #include "cc/trees/property_tree.h"
 #include "cc/trees/property_tree_builder.h"
 #include "ui/gfx/geometry/box_f.h"
 #include "ui/gfx/geometry/point_conversions.h"
+#include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
 
 LayerTreeImpl::LayerTreeImpl(
     LayerTreeHostImpl* layer_tree_host_impl,
     scoped_refptr<SyncedProperty<ScaleGroup>> page_scale_factor,
     scoped_refptr<SyncedTopControls> top_controls_shown_ratio,
     scoped_refptr<SyncedElasticOverscroll> elastic_overscroll)
@@ skipping 1370 matching lines @@
     const bool use_property_trees) {
   DCHECK(layer->render_surface());
   if (!use_property_trees)
     return layer->render_surface()->screen_space_transform();
   return layer->IsDrawnRenderSurfaceLayerListMember()
              ? layer->render_surface()->screen_space_transform()
              : SurfaceScreenSpaceTransformFromPropertyTrees(
                    layer->render_surface(), transform_tree);
 }
 
+static bool PointIsClippedByAncestorClipNode(
+    const gfx::PointF& screen_space_point,
+    const LayerImpl* layer,
+    const ClipTree& clip_tree,
+    const TransformTree& transform_tree) {
+  // We need to visit all ancestor clip nodes to check this. Checking with just
+  // the combined clip stored at a clip node is not enough because parent
+  // combined clip can sometimes be smaller than current combined clip. This can
+  // happen when we have transforms like rotation that inflate the combined
+  // clip's bounds. Also, the point can be clipped by the contect rect of an

[ajuma, 2016/01/06 19:53:44]

s/contect/content

[jaydasika, 2016/01/06 22:44:46]

Done.

+  // ancestor render surface.
+
+  // We first check if the point is clipped by viewport.
+  const ClipNode* clip_node = clip_tree.Node(1);
+  gfx::Rect combined_clip_in_target_space =
+      gfx::ToEnclosingRect(clip_node->data.combined_clip_in_target_space);
+  if (!PointHitsRect(screen_space_point, gfx::Transform(),
+                     combined_clip_in_target_space, NULL))
+    return true;
+
+  for (const ClipNode* clip_node = clip_tree.Node(layer->clip_tree_index());
+       clip_node->id > 1; clip_node = clip_tree.parent(clip_node)) {
+    if (clip_node->data.applies_local_clip) {
+      const TransformNode* transform_node =
+          transform_tree.Node(clip_node->data.transform_id);

[ajuma, 2016/01/06 19:53:44]

Should this be target_id (given that the clip we're using below is in target
space)? Do we have unit tests for the case that the clip node's own transform id
is different from its target id?

[jaydasika, 2016/01/06 22:44:45]

It should be target id. Did not find any unit test with that case. So added one.

+      gfx::Rect combined_clip_in_target_space =
+          gfx::ToEnclosingRect(clip_node->data.combined_clip_in_target_space);
+
+      if (!PointHitsRect(screen_space_point, transform_node->data.to_screen,
+                         combined_clip_in_target_space, NULL))
+        return true;
+    }
+    const LayerImpl* clip_node_owner =
+        layer->layer_tree_impl()->LayerById(clip_node->owner_id);
+    if (clip_node_owner->render_surface() &&
+        !PointHitsRect(
+            screen_space_point,
+            SurfaceScreenSpaceTransform(clip_node_owner, transform_tree,
+                                        true /*use_property_trees*/),
+            clip_node_owner->render_surface()->content_rect(), NULL)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 static bool PointIsClippedBySurfaceOrClipRect(
     const gfx::PointF& screen_space_point,
     const LayerImpl* layer,
     const TransformTree& transform_tree,
+    const ClipTree& clip_tree,
     const bool use_property_trees) {
   // Walk up the layer tree and hit-test any render_surfaces and any layer
   // clip rects that are active.
+  if (use_property_trees) {
+    return PointIsClippedByAncestorClipNode(screen_space_point, layer,
+                                            clip_tree, transform_tree);
+  }
+
   for (; layer; layer = GetNextClippingLayer(layer)) {
     if (layer->render_surface() &&
         !PointHitsRect(screen_space_point,
                        SurfaceScreenSpaceTransform(layer, transform_tree,
                                                    use_property_trees),
-                       layer->render_surface()->content_rect(), NULL))
+                       layer->render_surface()->content_rect(), NULL)) {
       return true;
+    }
 
     if (LayerClipsSubtree(layer) &&
         !PointHitsRect(screen_space_point, layer->ScreenSpaceTransform(),
-                       gfx::Rect(layer->bounds()), NULL))
+                       gfx::Rect(layer->bounds()), NULL)) {
       return true;
+    }
   }
 
   // If we have finished walking all ancestors without having already exited,
   // then the point is not clipped by any ancestors.
   return false;
 }
 
 static bool PointHitsLayer(const LayerImpl* layer,
                            const gfx::PointF& screen_space_point,
                            float* distance_to_intersection,
                            const TransformTree& transform_tree,
+                           const ClipTree& clip_tree,
                            const bool use_property_trees) {
   gfx::Rect content_rect(layer->bounds());
   if (!PointHitsRect(screen_space_point, layer->ScreenSpaceTransform(),
                      content_rect, distance_to_intersection))
     return false;
 
   // 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(screen_space_point, layer,
-                                        transform_tree, use_property_trees))
+                                        transform_tree, clip_tree,
+                                        use_property_trees))
     return false;
 
   // Skip the HUD layer.
   if (layer == layer->layer_tree_impl()->hud_layer())
     return false;
 
   return true;
 }
 
 struct FindClosestMatchingLayerDataForRecursion {
   FindClosestMatchingLayerDataForRecursion()
       : closest_match(NULL),
         closest_distance(-std::numeric_limits<float>::infinity()) {}
   LayerImpl* closest_match;
   // Note that the positive z-axis points towards the camera, so bigger means
   // closer in this case, counterintuitively.
   float closest_distance;
 };
 
 template <typename Functor>
 static void FindClosestMatchingLayer(
     const gfx::PointF& screen_space_point,
     LayerImpl* layer,
     const Functor& func,
     const TransformTree& transform_tree,
+    const ClipTree& clip_tree,
     const bool use_property_trees,
     FindClosestMatchingLayerDataForRecursion* data_for_recursion) {
   size_t children_size = layer->children().size();
   for (size_t i = 0; i < children_size; ++i) {
     size_t index = children_size - 1 - i;
     FindClosestMatchingLayer(screen_space_point, layer->children()[index].get(),
-                             func, transform_tree, use_property_trees,
-                             data_for_recursion);
+                             func, transform_tree, clip_tree,
+                             use_property_trees, data_for_recursion);
   }
 
   if (!func(layer))
     return;
 
   float distance_to_intersection = 0.f;
   bool hit = false;
   if (layer->Is3dSorted())
     hit = PointHitsLayer(layer, screen_space_point, &distance_to_intersection,
-                         transform_tree, use_property_trees);
+                         transform_tree, clip_tree, use_property_trees);
   else
     hit = PointHitsLayer(layer, screen_space_point, nullptr, transform_tree,
-                         use_property_trees);
+                         clip_tree, use_property_trees);
 
   if (!hit)
     return;
 
   bool in_front_of_previous_candidate =
       data_for_recursion->closest_match &&
       layer->sorting_context_id() ==
           data_for_recursion->closest_match->sorting_context_id() &&
       distance_to_intersection > data_for_recursion->closest_distance +
                                      std::numeric_limits<float>::epsilon();
@@ skipping 28 matching lines @@
   }
 };
 
 LayerImpl* LayerTreeImpl::FindFirstScrollingLayerThatIsHitByPoint(
     const gfx::PointF& screen_space_point) {
   FindClosestMatchingLayerDataForRecursion data_for_recursion;
   bool use_property_trees =
       settings().use_property_trees || settings().verify_property_trees;
   FindClosestMatchingLayer(
       screen_space_point, root_layer(), FindScrollingLayerFunctor(),
-      property_trees_.transform_tree, use_property_trees, &data_for_recursion);
+      property_trees_.transform_tree, property_trees_.clip_tree,
+      use_property_trees, &data_for_recursion);
   return data_for_recursion.closest_match;
 }
 
 struct HitTestVisibleScrollableOrTouchableFunctor {
   bool operator()(LayerImpl* layer) const {
     return layer->IsDrawnRenderSurfaceLayerListMember() ||
            ScrollsAnyDrawnRenderSurfaceLayerListMember(layer) ||
            !layer->touch_event_handler_region().IsEmpty() ||
            layer->have_wheel_event_handlers();
   }
 };
 
 LayerImpl* LayerTreeImpl::FindLayerThatIsHitByPoint(
     const gfx::PointF& screen_space_point) {
   if (!root_layer())
     return NULL;
   bool update_lcd_text = false;
   if (!UpdateDrawProperties(update_lcd_text))
     return NULL;
   bool use_property_trees =
       settings().use_property_trees || settings().verify_property_trees;
   FindClosestMatchingLayerDataForRecursion data_for_recursion;
   FindClosestMatchingLayer(screen_space_point, root_layer(),
                            HitTestVisibleScrollableOrTouchableFunctor(),
-                           property_trees_.transform_tree, use_property_trees,
+                           property_trees_.transform_tree,
+                           property_trees_.clip_tree, use_property_trees,
                            &data_for_recursion);
   return data_for_recursion.closest_match;
 }
 
 static bool LayerHasTouchEventHandlersAt(const gfx::PointF& screen_space_point,
                                          LayerImpl* layer_impl,
                                          const TransformTree& transform_tree,
+                                         const ClipTree& clip_tree,
                                          const bool use_property_trees) {
   if (layer_impl->touch_event_handler_region().IsEmpty())
     return false;
 
   if (!PointHitsRegion(screen_space_point, layer_impl->ScreenSpaceTransform(),
                        layer_impl->touch_event_handler_region()))
     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,
-                                        transform_tree, use_property_trees))
+                                        transform_tree, clip_tree,
+                                        use_property_trees))
     return false;
 
   return true;
 }
 
 struct FindWheelEventLayerFunctor {
   bool operator()(LayerImpl* layer) const {
     return layer->have_wheel_event_handlers();
   }
 };
 
 LayerImpl* LayerTreeImpl::FindLayerWithWheelHandlerThatIsHitByPoint(
     const gfx::PointF& screen_space_point) {
   if (!root_layer())
     return NULL;
   bool update_lcd_text = false;
   if (!UpdateDrawProperties(update_lcd_text))
     return NULL;
   bool use_property_trees =
       settings().use_property_trees || settings().verify_property_trees;
   FindWheelEventLayerFunctor func;
   FindClosestMatchingLayerDataForRecursion data_for_recursion;
-  FindClosestMatchingLayer(screen_space_point, root_layer(), func,
-                           property_trees_.transform_tree, use_property_trees,
-                           &data_for_recursion);
+  FindClosestMatchingLayer(
+      screen_space_point, root_layer(), func, property_trees_.transform_tree,
+      property_trees_.clip_tree, use_property_trees, &data_for_recursion);
   return data_for_recursion.closest_match;
 }
 
 struct FindTouchEventLayerFunctor {
   bool operator()(LayerImpl* layer) const {
     return LayerHasTouchEventHandlersAt(screen_space_point, layer,
-                                        transform_tree, use_property_trees);
+                                        transform_tree, clip_tree,
+                                        use_property_trees);
   }
   const gfx::PointF screen_space_point;
   const TransformTree& transform_tree;
+  const ClipTree& clip_tree;
   const bool use_property_trees;
 };
 
 LayerImpl* LayerTreeImpl::FindLayerThatIsHitByPointInTouchHandlerRegion(
     const gfx::PointF& screen_space_point) {
   if (!root_layer())
     return NULL;
   bool update_lcd_text = false;
   if (!UpdateDrawProperties(update_lcd_text))
     return NULL;
   bool use_property_trees =
       settings().use_property_trees || settings().verify_property_trees;
   FindTouchEventLayerFunctor func = {
-      screen_space_point, property_trees_.transform_tree, use_property_trees};
+      screen_space_point, property_trees_.transform_tree,
+      property_trees_.clip_tree, use_property_trees};
   FindClosestMatchingLayerDataForRecursion data_for_recursion;
-  FindClosestMatchingLayer(screen_space_point, root_layer(), func,
-                           property_trees_.transform_tree, use_property_trees,
-                           &data_for_recursion);
+  FindClosestMatchingLayer(
+      screen_space_point, root_layer(), func, property_trees_.transform_tree,
+      property_trees_.clip_tree, use_property_trees, &data_for_recursion);
   return data_for_recursion.closest_match;
 }
 
 void LayerTreeImpl::RegisterSelection(const LayerSelection& selection) {
   selection_ = selection;
 }
 
 static ViewportSelectionBound ComputeViewportSelectionBound(
     const LayerSelectionBound& layer_bound,
     LayerImpl* layer,
     float device_scale_factor,
     const TransformTree& transform_tree,
+    const ClipTree& clip_tree,
     const bool use_property_trees) {
   ViewportSelectionBound viewport_bound;
   viewport_bound.type = layer_bound.type;
 
   if (!layer || layer_bound.type == SELECTION_BOUND_EMPTY)
     return viewport_bound;
 
   auto layer_top = gfx::PointF(layer_bound.edge_top);
   auto layer_bottom = gfx::PointF(layer_bound.edge_bottom);
   gfx::Transform screen_space_transform = layer->ScreenSpaceTransform();
@@ skipping 25 matching lines @@
   visibility_offset.Scale(device_scale_factor / visibility_offset.Length());
   gfx::PointF visibility_point = layer_bottom + visibility_offset;
   if (visibility_point.x() <= 0)
     visibility_point.set_x(visibility_point.x() + device_scale_factor);
   visibility_point =
       MathUtil::MapPoint(screen_space_transform, visibility_point, &clipped);
 
   float intersect_distance = 0.f;
   viewport_bound.visible =
       PointHitsLayer(layer, visibility_point, &intersect_distance,
-                     transform_tree, use_property_trees);
+                     transform_tree, clip_tree, use_property_trees);
 
   return viewport_bound;
 }
 
 void LayerTreeImpl::GetViewportSelection(ViewportSelection* selection) {
   DCHECK(selection);
 
   bool use_property_trees =
       settings().use_property_trees || settings().verify_property_trees;
   selection->start = ComputeViewportSelectionBound(
       selection_.start,
       selection_.start.layer_id ? LayerById(selection_.start.layer_id) : NULL,
       device_scale_factor(), property_trees_.transform_tree,
-      use_property_trees);
+      property_trees_.clip_tree, use_property_trees);
   selection->is_editable = selection_.is_editable;
   selection->is_empty_text_form_control = selection_.is_empty_text_form_control;
   if (selection->start.type == SELECTION_BOUND_CENTER ||
       selection->start.type == SELECTION_BOUND_EMPTY) {
     selection->end = selection->start;
   } else {
     selection->end = ComputeViewportSelectionBound(
         selection_.end,
         selection_.end.layer_id ? LayerById(selection_.end.layer_id) : NULL,
         device_scale_factor(), property_trees_.transform_tree,
-        use_property_trees);
+        property_trees_.clip_tree, use_property_trees);
   }
 }
 
 void LayerTreeImpl::InputScrollAnimationFinished() {
   layer_tree_host_impl_->ScrollEnd();
 }
 
 bool LayerTreeImpl::SmoothnessTakesPriority() const {
   return layer_tree_host_impl_->GetTreePriority() == SMOOTHNESS_TAKES_PRIORITY;
 }
@@ skipping 180 matching lines @@
                                                    const gfx::BoxF& box,
                                                    gfx::BoxF* bounds) const {
   *bounds = gfx::BoxF();
   return layer_tree_host_impl_->animation_host()
              ? layer_tree_host_impl_->animation_host()
                    ->TransformAnimationBoundsForBox(layer->id(), box, bounds)
              : true;
 }
 
 }  // namespace cc