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 content rect of an
+  // 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.target_id);
+      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