cc : Compute render surface is_clipped outside property tree building

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 206 matching lines @@
   int target_transform_id = target_node->transform_id;
 
   bool cache_hit = false;
   ConditionalClip cached_clip = ConditionalClip{false, gfx::RectF()};
   ConditionalClip unclipped = ConditionalClip{false, gfx::RectF()};
 
   // Collect all the clips that need to be accumulated.
   std::stack<const ClipNode*, std::vector<const ClipNode*>> parent_chain;
 
   // If target is not direct ancestor of clip, this will find least common
-  // ancestor between the target and the clip.
+  // ancestor between the target and the clip. Or, if the target has a
+  // contributing layer that escapes clip, this will find the nearest ancestor
+  // that doesn't.
   while (target_node->clip_id > clip_node->id ||
-         target_node->has_unclipped_descendants) {
+         effect_tree.GetRenderSurface(target_node->id)
+             ->has_contributing_layer_that_escapes_clip()) {
     target_node = effect_tree.Node(target_node->target_id);
   }
 
   // Collect clip nodes up to the least common ancestor or till we get a cache
   // hit.
   while (target_node->clip_id < clip_node->id) {
     if (parent_chain.size() > 0) {
       // Search the cache.
       for (auto& data : clip_node->cached_clip_rects) {
         if (data.target_id == target_id) {
@@ skipping 71 matching lines @@
   cached_data->clip = clip;
   return clip;
 }
 
 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;
 }
 
+static int LowestCommonAncestor(int clip_id_1,
+                                int clip_id_2,
+                                const ClipTree* clip_tree) {
+  const ClipNode* clip_node_1 = clip_tree->Node(clip_id_1);
+  const ClipNode* clip_node_2 = clip_tree->Node(clip_id_2);
+  while (clip_node_1->id != clip_node_2->id) {
+    if (clip_node_1->id < clip_node_2->id)
+      clip_node_2 = clip_tree->parent(clip_node_2);
+    else
+      clip_node_1 = clip_tree->parent(clip_node_1);
+  }
+  return clip_node_1->id;
+}
+
+static void SetHasContributingLayerThatEscapesClip(int lca_clip_id,
+                                                   int target_effect_id,
+                                                   EffectTree* effect_tree) {
+  const EffectNode* effect_node = effect_tree->Node(target_effect_id);
+  // Find all ancestor targets starting from effect_node who are clipped by
+  // a descendant of lowest ancestor clip and set their
+  // has_contributing_layer_that_escapes_clip to true.
+  while (effect_node->clip_id > lca_clip_id) {
+    RenderSurfaceImpl* render_surface =
+        effect_tree->GetRenderSurface(effect_node->id);
+    DCHECK(render_surface);
+    render_surface->set_has_contributing_layer_that_escapes_clip(true);
+    effect_node = effect_tree->Node(effect_node->target_id);
+  }
+}
+
 template <typename LayerType>
 static int TransformTreeIndexForBackfaceVisibility(LayerType* layer,
                                                    const TransformTree& tree) {
   if (!layer->use_parent_backface_visibility())
     return layer->transform_tree_index();
   const TransformNode* node = tree.Node(layer->transform_tree_index());
   return layer->id() == node->owning_layer_id ? tree.parent(node)->id
                                               : node->id;
 }
 
@@ skipping 174 matching lines @@
 static gfx::Rect LayerDrawableContentRect(
     const LayerImpl* layer,
     const gfx::Rect& layer_bounds_in_target_space,
     const gfx::Rect& clip_rect) {
   if (layer->is_clipped())
     return IntersectRects(layer_bounds_in_target_space, clip_rect);
 
   return layer_bounds_in_target_space;
 }
 
+static void SetSurfaceIsClipped(const ClipTree& clip_tree,
+                                RenderSurfaceImpl* render_surface) {
+  bool is_clipped;
+  if (render_surface->EffectTreeIndex() == EffectTree::kContentsRootNodeId) {
+    // Root render surface is always clipped.
+    is_clipped = true;
+  } else if (render_surface->has_contributing_layer_that_escapes_clip()) {
+    // We cannot clip a surface that has a contribuitng layer which escapes the
+    // clip.
+    is_clipped = false;
+  } else if (render_surface->ClipTreeIndex() ==
+             render_surface->render_target()->ClipTreeIndex()) {
+    // There is no clip between between the render surface and its target, so
+    // the surface need not be clipped.
+    is_clipped = false;

[weiliangc, 2017/03/30 19:02:17]

I also think it's ok to clip here too. It will just be the same clip from its
parent.

[jaydasika, 2017/04/03 19:06:31]

Acknowledged. Will do in a follow-up.

+  } else {
+    // If the clips between the render surface and its target only expand the
+    // clips and do not apply any new clip, we need not clip the render surface.
+    const ClipNode* clip_node = clip_tree.Node(render_surface->ClipTreeIndex());
+    is_clipped = clip_node->clip_type != ClipNode::ClipType::EXPANDS_CLIP;

[weiliangc, 2017/03/30 19:02:17]

I think even with expansion this should still be is_clipped? The clip rect
calculated would still be valid after the expansion.

[jaydasika, 2017/04/03 19:06:31]

For this to happen, we need the other change (that is, if a render surface's
target is clipped and there is no clip in between, we still clip the render
surface). Because, if there is nothing but an expanding clip node between two
render surfaces, the current accumulating clips logic will return an empty rect
and if we set is_clipped true here, we will be clipping with an empty rect. So,
can this should also be pushed to the follow up ?

[weiliangc, 2017/04/04 20:56:38]

Yeah sounds good to have a follow up.

+  }
+  render_surface->SetIsClipped(is_clipped);
+}
+
 static void SetSurfaceDrawOpacity(const EffectTree& tree,
                                   RenderSurfaceImpl* render_surface) {
   // Draw opacity of a surface is the product of opacities between the surface
   // (included) and its target surface (excluded).
   const EffectNode* node = tree.Node(render_surface->EffectTreeIndex());
   float draw_opacity = tree.EffectiveOpacity(node);
   for (node = tree.parent(node); node && !node->has_render_surface;
        node = tree.parent(node)) {
     draw_opacity *= tree.EffectiveOpacity(node);
   }
@@ skipping 394 matching lines @@
         property_trees->transform_tree.Node(layer->transform_tree_index());
 
     layer->draw_properties().screen_space_transform =
         ScreenSpaceTransformInternal(layer, property_trees->transform_tree);
     layer->draw_properties().target_space_transform = DrawTransform(
         layer, property_trees->transform_tree, property_trees->effect_tree);
     layer->draw_properties().screen_space_transform_is_animating =
         transform_node->to_screen_is_potentially_animated;
   }
 
-  // Compute draw opacities
+  // Compute effects and determine if render surfaces have contributing layers
+  // that escape clip.
   for (LayerImpl* layer : *layer_list) {
     layer->draw_properties().opacity =
         LayerDrawOpacity(layer, property_trees->effect_tree);
+    RenderSurfaceImpl* render_target = layer->render_target();
+    int lca_clip_id = LowestCommonAncestor(layer->clip_tree_index(),
+                                           render_target->ClipTreeIndex(),
+                                           &property_trees->clip_tree);
+    if (lca_clip_id != render_target->ClipTreeIndex()) {
+      SetHasContributingLayerThatEscapesClip(lca_clip_id,
+                                             render_target->EffectTreeIndex(),
+                                             &property_trees->effect_tree);
+    }
   }
 
-  // Compute clips and viisble rects
+  // Compute clips and visible rects
   for (LayerImpl* layer : *layer_list) {
     ConditionalClip clip = LayerClipRect(property_trees, layer);
     // is_clipped should be set before visible rect computation as it is used
     // there.
     layer->draw_properties().is_clipped = clip.is_clipped;
     layer->draw_properties().clip_rect = gfx::ToEnclosingRect(clip.clip_rect);
     layer->draw_properties().visible_layer_rect =
         LayerVisibleRect(property_trees, layer);
   }
 
@@ skipping 14 matching lines @@
   mask_layer->draw_properties().screen_space_transform =
       ScreenSpaceTransformInternal(mask_layer,
                                    property_trees->transform_tree);
   mask_layer->draw_properties().visible_layer_rect =
       gfx::Rect(mask_layer->bounds());
 }
 
 void ComputeSurfaceDrawProperties(PropertyTrees* property_trees,
                                   RenderSurfaceImpl* render_surface,
                                   const bool use_layer_lists) {
-  const EffectNode* effect_node =
-      property_trees->effect_tree.Node(render_surface->EffectTreeIndex());
-  if (use_layer_lists) {
-    // TODO(crbug.com/702010) : Calculate surface's is_clipped value outside
-    // cc property tree building. This is a temporary hack to make SPv2 layout
-    // tests pass.
-    bool is_clipped = effect_node->id == EffectTree::kContentsRootNodeId ||
-                      (render_surface->render_target()->ClipTreeIndex() !=
-                       render_surface->ClipTreeIndex());
-    render_surface->SetIsClipped(is_clipped);
-  } else {
-    render_surface->SetIsClipped(effect_node->surface_is_clipped);
-  }
+  SetSurfaceIsClipped(property_trees->clip_tree, render_surface);
   SetSurfaceDrawOpacity(property_trees->effect_tree, render_surface);
   SetSurfaceDrawTransform(property_trees, render_surface);
   render_surface->SetScreenSpaceTransform(
       property_trees->ToScreenSpaceTransformWithoutSurfaceContentsScale(
           render_surface->TransformTreeIndex(),
           render_surface->EffectTreeIndex()));
 
   const ClipNode* clip_node =
       property_trees->clip_tree.Node(render_surface->ClipTreeIndex());
   SetSurfaceClipRect(clip_node, property_trees, render_surface);
@@ skipping 29 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