cc : Use sublayer scale from effect tree (4)

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 1660 matching lines @@
   // If ProjectPoint could not project to a valid value, then we assume that
   // this point doesn't hit this region.
   if (clipped)
     return false;
 
   return layer_space_region.Contains(
       gfx::ToRoundedPoint(hit_test_point_in_layer_space));
 }
 
 static const gfx::Transform SurfaceScreenSpaceTransform(
-    const LayerImpl* layer,
-    const TransformTree& transform_tree) {
+    const LayerImpl* layer) {
+  const PropertyTrees* property_trees =
+      layer->layer_tree_impl()->property_trees();
   DCHECK(layer->render_surface());
   return layer->is_drawn_render_surface_layer_list_member()
              ? layer->render_surface()->screen_space_transform()
-             : transform_tree.ToScreenSpaceTransformWithoutSurfaceContentsScale(
-                   layer->render_surface()->TransformTreeIndex());
+             : property_trees
+                   ->ToScreenSpaceTransformWithoutSurfaceContentsScale(
+                       layer->render_surface()->TransformTreeIndex(),
+                       layer->render_surface()->EffectTreeIndex());
 }
 
 static bool PointIsClippedByAncestorClipNode(
     const gfx::PointF& screen_space_point,
-    const LayerImpl* layer,
-    const ClipTree& clip_tree,
-    const TransformTree& transform_tree) {
+    const LayerImpl* layer) {
   // 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 PropertyTrees* property_trees =
+      layer->layer_tree_impl()->property_trees();
+  const ClipTree& clip_tree = property_trees->clip_tree;
+  const TransformTree& transform_tree = property_trees->transform_tree;
   const ClipNode* clip_node = clip_tree.Node(1);
   gfx::Rect combined_clip_in_target_space =
       gfx::ToEnclosingRect(clip_node->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->applies_local_clip) {
       const TransformNode* transform_node =
           transform_tree.Node(clip_node->target_transform_id);
       gfx::Rect combined_clip_in_target_space =
           gfx::ToEnclosingRect(clip_node->combined_clip_in_target_space);
 
       const LayerImpl* target_layer =
           layer->layer_tree_impl()->LayerById(transform_node->owner_id);
       DCHECK(transform_node->id == 0 || target_layer->render_surface() ||
              layer->layer_tree_impl()->is_in_resourceless_software_draw_mode());
       gfx::Transform surface_screen_space_transform =
           transform_node->id == 0 ||
                   (layer->layer_tree_impl()
                        ->is_in_resourceless_software_draw_mode())
               ? gfx::Transform()
-              : SurfaceScreenSpaceTransform(target_layer, transform_tree);
+              : SurfaceScreenSpaceTransform(target_layer);
       if (!PointHitsRect(screen_space_point, surface_screen_space_transform,
                          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),
+            screen_space_point, SurfaceScreenSpaceTransform(clip_node_owner),
             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 LayerImpl* layer) {
   // Walk up the layer tree and hit-test any render_surfaces and any layer
   // clip rects that are active.
-  return PointIsClippedByAncestorClipNode(screen_space_point, layer, clip_tree,
-                                          transform_tree);
+  return PointIsClippedByAncestorClipNode(screen_space_point, layer);
 }
 
 static bool PointHitsLayer(const LayerImpl* layer,
                            const gfx::PointF& screen_space_point,
-                           float* distance_to_intersection,
-                           const TransformTree& transform_tree,
-                           const ClipTree& clip_tree) {
+                           float* distance_to_intersection) {
   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, clip_tree))
+  if (PointIsClippedBySurfaceOrClipRect(screen_space_point, layer))
     return false;
 
   // Skip the HUD layer.
   if (layer == layer->layer_tree_impl()->hud_layer())
     return false;
 
   return true;
 }
 
 struct FindClosestMatchingLayerState {
   FindClosestMatchingLayerState()
       : 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* root_layer,
                                      const Functor& func,
-                                     const TransformTree& transform_tree,
-                                     const ClipTree& clip_tree,
                                      FindClosestMatchingLayerState* state) {
   // We want to iterate from front to back when hit testing.
   for (auto* layer : base::Reversed(*root_layer->layer_tree_impl())) {
     if (!func(layer))
       continue;
 
     float distance_to_intersection = 0.f;
     bool hit = false;
     if (layer->Is3dSorted())
-      hit = PointHitsLayer(layer, screen_space_point, &distance_to_intersection,
-                           transform_tree, clip_tree);
+      hit =
+          PointHitsLayer(layer, screen_space_point, &distance_to_intersection);
     else
-      hit = PointHitsLayer(layer, screen_space_point, nullptr, transform_tree,
-                           clip_tree);
+      hit = PointHitsLayer(layer, screen_space_point, nullptr);
 
     if (!hit)
       continue;
 
     bool in_front_of_previous_candidate =
         state->closest_match &&
         layer->sorting_context_id() ==
             state->closest_match->sorting_context_id() &&
         distance_to_intersection >
             state->closest_distance + std::numeric_limits<float>::epsilon();
@@ skipping 17 matching lines @@
     return ScrollsOrScrollbarAnyDrawnRenderSurfaceLayerListMember(layer);
   }
 };
 
 LayerImpl*
 LayerTreeImpl::FindFirstScrollingLayerOrScrollbarLayerThatIsHitByPoint(
     const gfx::PointF& screen_space_point) {
   FindClosestMatchingLayerState state;
   LayerImpl* root_layer = layer_list_.empty() ? nullptr : layer_list_[0];
   FindClosestMatchingLayer(screen_space_point, root_layer,
-                           FindScrollingLayerOrScrollbarLayerFunctor(),
-                           property_trees_.transform_tree,
-                           property_trees_.clip_tree, &state);
+                           FindScrollingLayerOrScrollbarLayerFunctor(), &state);
   return state.closest_match;
 }
 
 struct HitTestVisibleScrollableOrTouchableFunctor {
   bool operator()(LayerImpl* layer) const {
     return layer->is_drawn_render_surface_layer_list_member() ||
            ScrollsOrScrollbarAnyDrawnRenderSurfaceLayerListMember(layer) ||
            !layer->touch_event_handler_region().IsEmpty();
   }
 };
 
 LayerImpl* LayerTreeImpl::FindLayerThatIsHitByPoint(
     const gfx::PointF& screen_space_point) {
   if (layer_list_.empty())
     return NULL;
   bool update_lcd_text = false;
   if (!UpdateDrawProperties(update_lcd_text))
     return NULL;
   FindClosestMatchingLayerState state;
   FindClosestMatchingLayer(screen_space_point, layer_list_[0],
                            HitTestVisibleScrollableOrTouchableFunctor(),
-                           property_trees_.transform_tree,
-                           property_trees_.clip_tree, &state);
+                           &state);
   return state.closest_match;
 }
 
 static bool LayerHasTouchEventHandlersAt(const gfx::PointF& screen_space_point,
-                                         LayerImpl* layer_impl,
-                                         const TransformTree& transform_tree,
-                                         const ClipTree& clip_tree) {
+                                         LayerImpl* layer_impl) {
   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, clip_tree))
+  if (PointIsClippedBySurfaceOrClipRect(screen_space_point, layer_impl))
     return false;
 
   return true;
 }
 
 struct FindTouchEventLayerFunctor {
   bool operator()(LayerImpl* layer) const {
-    return LayerHasTouchEventHandlersAt(screen_space_point, layer,
-                                        transform_tree, clip_tree);
+    return LayerHasTouchEventHandlersAt(screen_space_point, layer);
   }
   const gfx::PointF screen_space_point;
-  const TransformTree& transform_tree;
-  const ClipTree& clip_tree;
 };
 
 LayerImpl* LayerTreeImpl::FindLayerThatIsHitByPointInTouchHandlerRegion(
     const gfx::PointF& screen_space_point) {
   if (layer_list_.empty())
     return NULL;
   bool update_lcd_text = false;
   if (!UpdateDrawProperties(update_lcd_text))
     return NULL;
-  FindTouchEventLayerFunctor func = {screen_space_point,
-                                     property_trees_.transform_tree,
-                                     property_trees_.clip_tree};
+  FindTouchEventLayerFunctor func = {screen_space_point};
   FindClosestMatchingLayerState state;
-  FindClosestMatchingLayer(screen_space_point, layer_list_[0], func,
-                           property_trees_.transform_tree,
-                           property_trees_.clip_tree, &state);
+  FindClosestMatchingLayer(screen_space_point, layer_list_[0], func, &state);
   return state.closest_match;
 }
 
 void LayerTreeImpl::RegisterSelection(const LayerSelection& selection) {
   selection_ = selection;
 }
 
 static gfx::SelectionBound ComputeViewportSelectionBound(
     const LayerSelectionBound& layer_bound,
     LayerImpl* layer,
-    float device_scale_factor,
-    const TransformTree& transform_tree,
-    const ClipTree& clip_tree) {
+    float device_scale_factor) {
   gfx::SelectionBound viewport_bound;
   viewport_bound.set_type(layer_bound.type);
 
   if (!layer || layer_bound.type == gfx::SelectionBound::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 22 matching lines @@
   // spuriously occlude the bound.
   gfx::Vector2dF visibility_offset = layer_top - layer_bottom;
   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.set_visible(PointHitsLayer(
-      layer, visibility_point, &intersect_distance, transform_tree, clip_tree));
+  viewport_bound.set_visible(
+      PointHitsLayer(layer, visibility_point, &intersect_distance));
 
   return viewport_bound;
 }
 
 void LayerTreeImpl::GetViewportSelection(
     Selection<gfx::SelectionBound>* selection) {
   DCHECK(selection);
 
   selection->start = ComputeViewportSelectionBound(
       selection_.start,
       selection_.start.layer_id ? LayerById(selection_.start.layer_id) : NULL,
-      device_scale_factor(), property_trees_.transform_tree,
-      property_trees_.clip_tree);
+      device_scale_factor());
   selection->is_editable = selection_.is_editable;
   selection->is_empty_text_form_control = selection_.is_empty_text_form_control;
   if (selection->start.type() == gfx::SelectionBound::CENTER ||
       selection->start.type() == gfx::SelectionBound::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,
-        property_trees_.clip_tree);
+        device_scale_factor());
   }
 }
 
 bool LayerTreeImpl::SmoothnessTakesPriority() const {
   return layer_tree_host_impl_->GetTreePriority() == SMOOTHNESS_TAKES_PRIORITY;
 }
 
 VideoFrameControllerClient* LayerTreeImpl::GetVideoFrameControllerClient()
     const {
   return layer_tree_host_impl_;
@@ skipping 16 matching lines @@
 
 void LayerTreeImpl::ResetAllChangeTracking() {
   layers_that_should_push_properties_.clear();
   // Iterate over all layers, including masks and replicas.
   for (auto& layer : *layers_)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking();
 }
 
 }  // namespace cc