cc : Compute visible rects dynamically (2)

cc/trees/draw_property_utils.cc

 // Copyright 2014 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/draw_property_utils.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 362 matching lines @@
         layer->set_clip_rect(gfx::ToEnclosingRect(clip_rect_in_target_space));
       } else {
         layer->set_clip_rect(gfx::Rect());
       }
     }
   }
 }
 
 void CalculateVisibleRects(const LayerImplList& visible_layer_list,
                            const PropertyTrees* property_trees,
-                           bool non_root_surfaces_enabled,
-                           bool verify_visible_rect_calculations) {
+                           bool non_root_surfaces_enabled) {
   const EffectTree& effect_tree = property_trees->effect_tree;
   const TransformTree& transform_tree = property_trees->transform_tree;
   const ClipTree& clip_tree = property_trees->clip_tree;
   for (auto& layer : visible_layer_list) {
     gfx::Size layer_bounds = layer->bounds();
 
     int effect_ancestor_with_copy_request =
         effect_tree.ClosestAncestorWithCopyRequest(layer->effect_tree_index());
     if (effect_ancestor_with_copy_request > 1) {
       // Non root copy request.
@@ skipping 158 matching lines @@
     }
     gfx::Transform target_to_content;
     target_to_content.Translate(-layer->offset_to_transform_parent().x(),
                                 -layer->offset_to_transform_parent().y());
     target_to_content.PreconcatTransform(target_to_layer);
 
     gfx::Rect visible_rect = gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
         target_to_content, combined_clip_rect_in_target_space));
     visible_rect.Intersect(gfx::Rect(layer_bounds));
     layer->set_visible_layer_rect(visible_rect);
-
-    if (verify_visible_rect_calculations) {
-      gfx::Rect visible_rect_dynamic =
-          ComputeLayerVisibleRectDynamic(property_trees, layer);
-      DCHECK(layer->visible_layer_rect() == visible_rect_dynamic)
-          << " layer: " << layer->id()
-          << " clip id: " << layer->clip_tree_index()
-          << " visible rect cached: " << layer->visible_layer_rect().ToString()
-          << " v.s. "
-          << " visible rect dynamic: " << visible_rect_dynamic.ToString();
-    }
   }
 }
 
 static bool HasSingularTransform(int transform_tree_index,
                                  const TransformTree& tree) {
   const TransformNode* node = tree.Node(transform_tree_index);
   return !node->is_invertible || !node->ancestors_are_invertible;
 }
 
 template <typename LayerType>
@@ skipping 526 matching lines @@
       << DrawTransform(layer, property_trees->transform_tree,
                        property_trees->effect_tree)
              .ToString()
       << " v.s." << draw_transform.ToString();
 }
 
 static void ComputeVisibleRectsInternal(
     LayerImpl* root_layer,
     PropertyTrees* property_trees,
     bool can_render_to_separate_surface,
-    bool verify_visible_rect_calculations,
     std::vector<LayerImpl*>* visible_layer_list) {
   if (property_trees->non_root_surfaces_enabled !=
       can_render_to_separate_surface) {
     property_trees->non_root_surfaces_enabled = can_render_to_separate_surface;
     property_trees->transform_tree.set_needs_update(true);
   }
   if (property_trees->transform_tree.needs_update()) {
     property_trees->clip_tree.set_needs_update(true);
     property_trees->effect_tree.set_needs_update(true);
   }
   UpdateRenderTarget(&property_trees->effect_tree,
                      property_trees->non_root_surfaces_enabled);
   ComputeTransforms(&property_trees->transform_tree);
   // Computation of clips uses surface contents scale which is updated while
   // computing effects. So, ComputeEffects should be before ComputeClips.
   ComputeEffects(&property_trees->effect_tree);
   ComputeClips(property_trees, can_render_to_separate_surface);
 
   FindLayersThatNeedUpdates(root_layer->layer_tree_impl(),
                             property_trees->transform_tree,
                             property_trees->effect_tree, visible_layer_list);
   CalculateClipRects<LayerImpl>(*visible_layer_list, property_trees,
                                 can_render_to_separate_surface);
   CalculateVisibleRects(*visible_layer_list, property_trees,
-                        can_render_to_separate_surface,
-                        verify_visible_rect_calculations);
+                        can_render_to_separate_surface);
 }
 
 void UpdatePropertyTrees(PropertyTrees* property_trees,
                          bool can_render_to_separate_surface) {
   if (property_trees->non_root_surfaces_enabled !=
       can_render_to_separate_surface) {
     property_trees->non_root_surfaces_enabled = can_render_to_separate_surface;
     property_trees->transform_tree.set_needs_update(true);
   }
   if (property_trees->transform_tree.needs_update()) {
@@ skipping 12 matching lines @@
     const LayerImpl* page_scale_layer,
     const LayerImpl* inner_viewport_scroll_layer,
     const LayerImpl* outer_viewport_scroll_layer,
     const LayerImpl* overscroll_elasticity_layer,
     const gfx::Vector2dF& elastic_overscroll,
     float page_scale_factor,
     float device_scale_factor,
     const gfx::Rect& viewport,
     const gfx::Transform& device_transform,
     bool can_render_to_separate_surface,
-    bool verify_visible_rect_calculations,
     PropertyTrees* property_trees,
     LayerImplList* visible_layer_list) {
   PropertyTreeBuilder::BuildPropertyTrees(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees);
   ComputeVisibleRects(root_layer, property_trees,
-                      can_render_to_separate_surface,
-                      verify_visible_rect_calculations, visible_layer_list);
+                      can_render_to_separate_surface, visible_layer_list);
 }
 
 void VerifyClipTreeCalculations(const LayerImplList& layer_list,
                                 PropertyTrees* property_trees) {
   if (property_trees->non_root_surfaces_enabled) {
     ComputeClipsWithEffectTree(property_trees);
   }
   for (auto* layer : layer_list)
     ComputeLayerClipRect(property_trees, layer);
 }
 
 void VerifyTransformTreeCalculations(const LayerImplList& layer_list,
                                      PropertyTrees* property_trees) {
   for (auto* layer : layer_list)
     VerifyDrawTransformsMatch(layer, property_trees);
 }
 
 void ComputeVisibleRects(LayerImpl* root_layer,
                          PropertyTrees* property_trees,
                          bool can_render_to_separate_surface,
-                         bool verify_visible_rect_calculations,
                          LayerImplList* visible_layer_list) {
   for (auto* layer : *root_layer->layer_tree_impl()) {
     UpdateRenderSurfaceForLayer(&property_trees->effect_tree,
                                 can_render_to_separate_surface, layer);
     EffectNode* node =
         property_trees->effect_tree.Node(layer->effect_tree_index());
     if (node->owner_id == layer->id())
       node->render_surface = layer->render_surface();
 #if DCHECK_IS_ON()
     if (can_render_to_separate_surface)
       ValidateRenderSurfaceForLayer(layer);
 #endif
   }
-  ComputeVisibleRectsInternal(
-      root_layer, property_trees, can_render_to_separate_surface,
-      verify_visible_rect_calculations, visible_layer_list);
+  ComputeVisibleRectsInternal(root_layer, property_trees,
+                              can_render_to_separate_surface,
+                              visible_layer_list);
 }
 
 gfx::Rect ComputeLayerVisibleRectDynamic(const PropertyTrees* property_trees,
                                          const LayerImpl* layer) {
-  gfx::RectF accumulated_clip_in_root_space =
-      ComputeAccumulatedClipInRootSpaceForVisibleRect(property_trees,
-                                                      layer->clip_tree_index());
+  int effect_ancestor_with_copy_request =
+      property_trees->effect_tree.ClosestAncestorWithCopyRequest(
+          layer->effect_tree_index());
+  bool non_root_copy_request =
+      effect_ancestor_with_copy_request > EffectTree::kContentsRootNodeId;
+  gfx::Rect layer_content_rect = gfx::Rect(layer->bounds());
+  gfx::RectF accumulated_clip_in_root_space;
+  if (non_root_copy_request) {
+    ConditionalClip accumulated_clip =
+        ComputeAccumulatedClip(property_trees, layer->clip_tree_index(),
+                               effect_ancestor_with_copy_request);
+    if (!accumulated_clip.is_clipped)
+      return layer_content_rect;
+    accumulated_clip_in_root_space = accumulated_clip.clip_rect;
+  } else {
+    accumulated_clip_in_root_space =
+        ComputeAccumulatedClipInRootSpaceForVisibleRect(
+            property_trees, layer->clip_tree_index());
+  }
 
   const EffectNode* root_effect_node =
-      property_trees->effect_tree.Node(EffectTree::kContentsRootNodeId);
+      non_root_copy_request
+          ? property_trees->effect_tree.Node(effect_ancestor_with_copy_request)
+          : property_trees->effect_tree.Node(EffectTree::kContentsRootNodeId);
   ConditionalClip accumulated_clip_in_layer_space =
       ComputeTargetRectInLocalSpace(
           accumulated_clip_in_root_space, property_trees,
           root_effect_node->transform_id, layer->transform_tree_index(),
           root_effect_node->id);
+  if (!accumulated_clip_in_layer_space.is_clipped)
+    return layer_content_rect;
   gfx::RectF clip_in_layer_space = accumulated_clip_in_layer_space.clip_rect;
   clip_in_layer_space.Offset(-layer->offset_to_transform_parent());
 
-  gfx::Rect layer_content_rect = gfx::Rect(layer->bounds());
   gfx::Rect visible_rect = gfx::ToEnclosingRect(clip_in_layer_space);
   visible_rect.Intersect(layer_content_rect);
   return visible_rect;
 }
 
+void VerifyVisibleRectsCalculations(const LayerImplList& layer_list,
+                                    const PropertyTrees* property_trees) {
+  for (auto layer : layer_list) {
+    gfx::Rect visible_rect_dynamic =
+        ComputeLayerVisibleRectDynamic(property_trees, layer);
+    DCHECK(layer->visible_layer_rect() == visible_rect_dynamic)
+        << " layer: " << layer->id() << " clip id: " << layer->clip_tree_index()
+        << " visible rect cached: " << layer->visible_layer_rect().ToString()
+        << " v.s. "
+        << " visible rect dynamic: " << visible_rect_dynamic.ToString();
+  }
+}
+
 bool LayerNeedsUpdate(Layer* layer,
                       bool layer_is_drawn,
                       const TransformTree& tree) {
   return LayerNeedsUpdateInternal(layer, layer_is_drawn, tree);
 }
 
 bool LayerNeedsUpdate(LayerImpl* layer,
                       bool layer_is_drawn,
                       const TransformTree& tree) {
   return LayerNeedsUpdateInternal(layer, layer_is_drawn, tree);
@@ skipping 399 matching lines @@
 void UpdateElasticOverscroll(PropertyTrees* property_trees,
                              const Layer* overscroll_elasticity_layer,
                              const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer,
                                   elastic_overscroll);
 }
 
 }  // namespace draw_property_utils
 
 }  // namespace cc