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 298 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;
+  }
+  NOTREACHED();
+  return gfx::RectF();
+}
+
+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;
+  if (local_clip_id == target_node->data.clip_id)

[ajuma, 2016/03/15 14:59:56]

This confused me for a bit since it seemed like this was checking the common
case of something having the same clip node as its target, in which case we'd
also need to check if the target has unclipped descendants, but (given that we
currently always create a clip node for each target), I think this is actually
checking if the local clip is the same as the parent of the clip node created
for the target? So, e.g., this would happen for a layer with a clip parent? If
so, could there be other clips in between the clip parent and the next clipped
target that also need to be accumulated?

[weiliangc, 2016/03/15 15:29:36]

This is a special case I started with, but is no longer needed. The following
code handles this case naturally. So going to remove this.

Maybe this is only true when we have two render surfaces without no clip in
between?

+    return ComputeCurrentClip(clip_tree.Node(local_clip_id), transform_tree,
+                              target_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->id != 1 && !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 && clip_node->id != 1)
+    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 && clip_node->id != 1) {

[ajuma, 2016/03/15 14:59:56]

Do we still need this special handling for the viewport clip? (Are there cases
where the viewport clip needs to be included in a clip rect?)

[weiliangc, 2016/03/15 15:29:36]

No, I realized viewport clip always applies local clip. Removed.

+      continue;
+    }
+    gfx::RectF current_clip =
+        ComputeCurrentClip(clip_node, transform_tree, target_transform_id);
+    accumulated_clip = gfx::IntersectRects(accumulated_clip, current_clip);
+  }
+
+  return 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) {
+      CHECK(accumulated_clip == clip_node->data.clip_in_target_space);
+    }
+    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 ||
+      clip_tree->Node(layer->clip_tree_index())->data.layers_are_clipped) {
+    CHECK(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 73 matching lines @@
 }
 
 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);
+  if (can_render_to_separate_surface)
+    ComputeClipsWithEffectTree(property_trees);
   LayerImplList update_layer_list;
   ComputeVisibleRectsInternal(root_layer, property_trees,
                               can_render_to_separate_surface,
                               &update_layer_list, visible_layer_list);
+  if (can_render_to_separate_surface)
+    for (auto layer : *visible_layer_list)
+      ComputeLayerClipRect(property_trees, layer);
 }
 
 template <typename LayerType>
 static gfx::Transform DrawTransformInternal(const LayerType* layer,
                                             const TransformNode* node) {
   gfx::Transform xform;
   const bool owns_non_root_surface =
       layer->parent() && layer->has_render_surface();
   if (!owns_non_root_surface) {
     // If you're not the root, or you don't own a surface, you need to apply
@@ skipping 34 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)
+      << "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 220 matching lines @@
                                             replica_to_surface);
     render_surface->SetReplicaScreenSpaceTransform(
         render_surface->screen_space_transform() * replica_to_surface);
   } else {
     render_surface->SetReplicaDrawTransform(gfx::Transform());
     render_surface->SetReplicaScreenSpaceTransform(gfx::Transform());
   }
 
   SetSurfaceClipRect(property_trees->clip_tree.parent(clip_node),
                      property_trees->transform_tree, render_surface);
+
+  if (!property_trees->non_root_surfaces_enabled)
+    return;
+
+  if (render_surface->is_clipped()) {
+    const EffectNode* effect_node =
+        property_trees->effect_tree.Node(render_surface->EffectTreeIndex());
+    DCHECK(effect_node->data.has_render_surface);
+    CHECK(effect_node->data.clip_rect == render_surface->clip_rect())
+        << "effect tree's: " << effect_node->data.clip_rect.ToString()
+        << " clip: " << render_surface->clip_rect().ToString();
+  }
 }
 
 template <typename LayerType>
 static void UpdatePageScaleFactorInternal(PropertyTrees* property_trees,
                                           const LayerType* page_scale_layer,
                                           float page_scale_factor,
                                           float device_scale_factor,
                                           gfx::Transform device_transform) {
   if (property_trees->transform_tree.page_scale_factor() == page_scale_factor)
     return;
@@ skipping 75 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