cc: Directly use property trees to calculate clip rect

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 115 matching lines @@
         if (clip_node->data.target_id < target_node->id) {
           combined_clip_rect_in_target_space =
               gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
                   clip_to_target, clip_node->data.clip_in_target_space));
         } else {
           combined_clip_rect_in_target_space =
               gfx::ToEnclosingRect(MathUtil::MapClippedRect(
                   clip_to_target, clip_node->data.clip_in_target_space));
         }
         clip_rect_in_target_space = combined_clip_rect_in_target_space;
-
       } else {
         clip_rect_in_target_space =
             gfx::ToEnclosingRect(clip_node->data.clip_in_target_space);
         if (clip_node->data.target_is_clipped || !non_root_surfaces_enabled)
           combined_clip_rect_in_target_space = gfx::ToEnclosingRect(
               clip_node->data.combined_clip_in_target_space);
         else
           combined_clip_rect_in_target_space = clip_rect_in_target_space;
       }
 
@@ skipping 300 matching lines @@
   }
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
     FindLayersThatNeedUpdates(layer->child_at(i), transform_tree, effect_tree,
                               update_layer_list, visible_layer_list);
   }
 }
 
 template <typename LayerType>
 void UpdateRenderSurfacesWithEffectTreeInternal(EffectTree* effect_tree,
-                                                LayerType* layer) {
+                                                LayerType* layer,
+                                                int target_id) {
   EffectNode* node = effect_tree->Node(layer->effect_tree_index());
+  if (node->owner_id == layer->id())
+    node->data.target_id = target_id;
 
-  if (node->owner_id == layer->id() && node->data.has_render_surface)
+  if (node->owner_id == layer->id() && node->data.has_render_surface) {
     layer->SetHasRenderSurface(true);
-  else
+    target_id = node->id;
+  } else {
     layer->SetHasRenderSurface(false);
+  }
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
-    UpdateRenderSurfacesWithEffectTreeInternal<LayerType>(effect_tree,
-                                                          layer->child_at(i));
+    UpdateRenderSurfacesWithEffectTreeInternal<LayerType>(
+        effect_tree, layer->child_at(i), target_id);
   }
 }
 
 void UpdateRenderSurfacesWithEffectTree(EffectTree* effect_tree, Layer* layer) {
-  UpdateRenderSurfacesWithEffectTreeInternal<Layer>(effect_tree, layer);
+  UpdateRenderSurfacesWithEffectTreeInternal<Layer>(effect_tree, layer, 0);
 }
 
 void UpdateRenderSurfacesNonRootSurfacesDisabled(LayerImpl* layer) {
   // Only root layer has render surface, all other layers don't.
   layer->SetHasRenderSurface(!layer->parent());
 
   for (size_t i = 0; i < layer->children().size(); ++i)
     UpdateRenderSurfacesNonRootSurfacesDisabled(layer->child_at(i));
 }
 
 void UpdateRenderSurfacesWithEffectTree(EffectTree* effect_tree,
                                         bool non_root_surfaces_enabled,
                                         LayerImpl* layer) {
   if (!non_root_surfaces_enabled)
     UpdateRenderSurfacesNonRootSurfacesDisabled(layer);
   else
-    UpdateRenderSurfacesWithEffectTreeInternal<LayerImpl>(effect_tree, layer);
+    UpdateRenderSurfacesWithEffectTreeInternal<LayerImpl>(effect_tree, layer,
+                                                          0);
 }
 
 }  // namespace
 
 static void ResetIfHasNanCoordinate(gfx::RectF* rect) {
   if (std::isnan(rect->x()) || std::isnan(rect->y()) ||
       std::isnan(rect->right()) || std::isnan(rect->bottom()))
     *rect = gfx::RectF();
 }
 
@@ skipping 144 matching lines @@
 }
 
 void ComputeEffects(EffectTree* effect_tree) {
   if (!effect_tree->needs_update())
     return;
   for (int i = 1; i < static_cast<int>(effect_tree->size()); ++i)
     effect_tree->UpdateEffects(i);
   effect_tree->set_needs_update(false);
 }
 
+static gfx::RectF ComputeCurrentClip(const ClipNode* clip_node,
+                                     const TransformTree& transform_tree,
+                                     int target_transform_id) {
+  if (clip_node->data.transform_id != target_transform_id) {
+    gfx::Transform current_to_target;
+    if (!transform_tree.ComputeTransformWithDestinationSublayerScale(
+            clip_node->data.transform_id, target_transform_id,
+            &current_to_target))
+      return gfx::RectF();
+    if (clip_node->data.transform_id > target_transform_id)
+      return MathUtil::MapClippedRect(current_to_target, clip_node->data.clip);
+    else
+      return MathUtil::ProjectClippedRect(current_to_target,
+                                          clip_node->data.clip);
+  } else {
+    gfx::RectF current_clip = clip_node->data.clip;
+    gfx::Vector2dF sublayer_scale =
+        transform_tree.Node(target_transform_id)->data.sublayer_scale;
+    if (sublayer_scale.x() > 0 && sublayer_scale.y() > 0) {
+      current_clip.Scale(sublayer_scale.x(), sublayer_scale.y());
+    }
+    return current_clip;
+  }
+}
+
+static gfx::RectF ComputeAccumulatedClip(const ClipTree& clip_tree,
+                                         int local_clip_id,
+                                         const EffectTree& effect_tree,
+                                         int target_id,
+                                         const TransformTree& transform_tree) {
+  const ClipNode* clip_node = clip_tree.Node(local_clip_id);
+  const EffectNode* target_node = effect_tree.Node(target_id);
+  int target_transform_id = target_node->data.transform_id;
+
+  // Collect all the clips that need to be accumulated.
+  std::stack<const ClipNode*> parent_chain;
+
+  // If target is not direct ancestor of clip, this will find least common
+  // ancestor between the target and the clip.
+  while (target_node->id >= 0 && clip_node->id >= 0) {
+    while (target_node->data.clip_id > clip_node->id ||
+           target_node->data.has_unclipped_descendants) {
+      target_node = effect_tree.Node(target_node->data.target_id);
+    }
+    if (target_node->data.clip_id == clip_node->id)
+      break;
+    while (target_node->data.clip_id < clip_node->id) {
+      parent_chain.push(clip_node);
+      clip_node = clip_tree.parent(clip_node);
+    }
+    if (target_node->data.clip_id == clip_node->id) {
+      clip_node = parent_chain.top();
+      parent_chain.pop();
+      break;
+    }
+  }
+
+  // TODO(weiliangc): If we don't create clip for render surface, we don't need
+  // to check applies_local_clip.
+  while (!clip_node->data.applies_local_clip && parent_chain.size() > 0) {
+    clip_node = parent_chain.top();
+    parent_chain.pop();
+  }
+
+  if (!clip_node->data.applies_local_clip)
+    return gfx::RectF();
+
+  gfx::RectF accumulated_clip =
+      ComputeCurrentClip(clip_node, transform_tree, target_transform_id);
+
+  while (parent_chain.size() > 0) {
+    clip_node = parent_chain.top();
+    parent_chain.pop();
+    if (!clip_node->data.applies_local_clip) {
+      continue;
+    }
+    gfx::RectF current_clip =
+        ComputeCurrentClip(clip_node, transform_tree, target_transform_id);
+
+    if (current_clip.IsEmpty())
+      return gfx::RectF();
+
+    accumulated_clip = gfx::IntersectRects(accumulated_clip, current_clip);
+  }
+
+  return accumulated_clip.IsEmpty() ? gfx::RectF() : accumulated_clip;
+}
+
+static void ComputeClipsWithEffectTree(PropertyTrees* property_trees) {
+  EffectTree* effect_tree = &property_trees->effect_tree;
+  const ClipTree* clip_tree = &property_trees->clip_tree;
+  const TransformTree* transform_tree = &property_trees->transform_tree;
+  EffectNode* root_effect_node = effect_tree->Node(1);
+  root_effect_node->data.clip_rect = gfx::ToEnclosingRect(
+      clip_tree->Node(root_effect_node->data.clip_id)->data.clip);
+  for (int i = 2; i < static_cast<int>(effect_tree->size()); ++i) {
+    EffectNode* effect_node = effect_tree->Node(i);
+    const EffectNode* target_node =
+        effect_tree->Node(effect_node->data.target_id);
+    gfx::RectF accumulated_clip =
+        ComputeAccumulatedClip(*clip_tree, effect_node->data.clip_id,
+                               *effect_tree, target_node->id, *transform_tree);
+
+    const ClipNode* clip_node = clip_tree->Node(effect_node->data.clip_id);
+    if (!clip_node->data.applies_local_clip &&
+        !effect_node->data.has_unclipped_descendants) {
+      DCHECK(accumulated_clip == clip_node->data.clip_in_target_space);

[ajuma, 2016/03/19 00:29:41]

The original patch also had logic to compare the effect node clip rect to the
surface's computed clip_rect for clipped surfaces. Did you mean to move that
logic here rather than deleting it? There doesn't seem to be a nice way to get
the surface here (to check is_clipped), but I think changing the 'if' condition
to ((clip->node->data.layers_are_clipped || effect_node->id == 0)  &&
!effect_node->data.has_unclipped_descendants &&
effect_node->data.has_render_surface) is equivalent to having a clipped surface.
(Please also include the two rects in the output of the DCHECK, like the DCHECK
for layer clip rects below.)

[weiliangc, 2016/05/11 23:08:08]

Added the logic back. Now the verification on render surface should run after
render surface calculated draw property behind the flag.

+    }
+    effect_node->data.clip_rect = gfx::ToEnclosingRect(accumulated_clip);
+  }
+}
+
+static void ComputeLayerClipRect(const PropertyTrees* property_trees,
+                                 const LayerImpl* layer) {
+  const EffectTree* effect_tree = &property_trees->effect_tree;
+  const ClipTree* clip_tree = &property_trees->clip_tree;
+  const TransformTree* transform_tree = &property_trees->transform_tree;
+  const EffectNode* effect_node = effect_tree->Node(layer->effect_tree_index());
+  const EffectNode* target_node =
+      effect_node->data.has_render_surface
+          ? effect_node
+          : effect_tree->Node(effect_node->data.target_id);
+
+  gfx::RectF accumulated_clip =
+      ComputeAccumulatedClip(*clip_tree, layer->clip_tree_index(), *effect_tree,
+                             target_node->id, *transform_tree);
+  if (!property_trees->non_root_surfaces_enabled ||

[ajuma, 2016/03/19 00:29:41]

Since this is currently only called when non_root_surfaces_enabled is true, it
might be clearer to remove this condition for now.

[weiliangc, 2016/05/11 23:08:08]

Added computation and verification for resourceless software draw so edited this
condition.

+      clip_tree->Node(layer->clip_tree_index())->data.layers_are_clipped) {
+    DCHECK(layer->clip_rect() == gfx::ToEnclosingRect(accumulated_clip))
+        << " layer: " << layer->id() << " clip id: " << layer->clip_tree_index()
+        << " layer clip: " << layer->clip_rect().ToString() << " v.s. "
+        << gfx::ToEnclosingRect(accumulated_clip).ToString()
+        << " and clip node clip: "
+        << gfx::ToEnclosingRect(clip_tree->Node(layer->clip_tree_index())
+                                    ->data.clip_in_target_space)
+               .ToString();
+  }
+}
+
 template <typename LayerType>
 static void ComputeVisibleRectsInternal(
     LayerType* root_layer,
     PropertyTrees* property_trees,
     bool can_render_to_separate_surface,
     typename LayerType::LayerListType* update_layer_list,
     std::vector<LayerType*>* 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;
@@ skipping 65 matching lines @@
 void ComputeVisibleRects(Layer* root_layer,
                          PropertyTrees* property_trees,
                          bool can_render_to_separate_surface,
                          LayerList* update_layer_list) {
   std::vector<Layer*> visible_layer_list;
   ComputeVisibleRectsInternal(root_layer, property_trees,
                               can_render_to_separate_surface, update_layer_list,
                               &visible_layer_list);
 }
 
+void VerifyClipTreeCalculations(const LayerImplList& layer_list,
+                                PropertyTrees* property_trees) {
+  if (property_trees->non_root_surfaces_enabled) {

[ajuma, 2016/03/19 00:29:41]

Just to make sure I understand, the reason this doesn't work yet with non-root
surfaces disabled is that the has_render_surface value on each node is currently
only updated on the main thread?

[weiliangc, 2016/05/11 23:08:08]

Yes. I have added a hack to the computation (aka everybody has root as target)
so we can verify for resourceless draw unitttests as well.

+    ComputeClipsWithEffectTree(property_trees);
+    for (auto layer : layer_list)
+      ComputeLayerClipRect(property_trees, layer);
+  }
+}
+
 void ComputeVisibleRects(LayerImpl* root_layer,
                          PropertyTrees* property_trees,
                          bool can_render_to_separate_surface,
                          LayerImplList* visible_layer_list) {
   UpdateRenderSurfacesWithEffectTree(
       &property_trees->effect_tree, can_render_to_separate_surface, root_layer);
   if (can_render_to_separate_surface)
     ValidateRenderSurfaces(root_layer);
   LayerImplList update_layer_list;
   ComputeVisibleRectsInternal(root_layer, property_trees,
@@ skipping 46 matching lines @@
                                                     &render_surface_transform);
   if (node->data.sublayer_scale.x() != 0.0 &&
       node->data.sublayer_scale.y() != 0.0)
     render_surface_transform.Scale(1.0 / node->data.sublayer_scale.x(),
                                    1.0 / node->data.sublayer_scale.y());
   render_surface->SetDrawTransform(render_surface_transform);
 }
 
 static void SetSurfaceIsClipped(const ClipNode* clip_node,
                                 RenderSurfaceImpl* render_surface) {
+  DCHECK(render_surface->OwningLayerId() == clip_node->owner_id)

[ajuma, 2016/03/19 00:29:41]

Since we now have this DCHECK, the 'if' below can be removed.

[weiliangc, 2016/05/11 23:08:08]

Done.

+      << "we now create clip node for every render surface";
   // If the render surface's owning layer doesn't form a clip node, it is not
   // clipped.
   if (render_surface->OwningLayerId() != clip_node->owner_id)
     render_surface->SetIsClipped(false);
   else
     render_surface->SetIsClipped(clip_node->data.target_is_clipped);
 }
 
 static void SetSurfaceClipRect(const ClipNode* parent_clip_node,
                                const TransformTree& transform_tree,
@@ skipping 315 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