Add ClipNode when Render Surface Inherits Clip

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 <vector>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/layer.h"
@@ skipping 370 matching lines @@
 void ComputeClips(ClipTree* clip_tree, const TransformTree& transform_tree) {
   if (!clip_tree->needs_update())
     return;
   for (int i = 0; i < static_cast<int>(clip_tree->size()); ++i) {
     ClipNode* clip_node = clip_tree->Node(i);
 
     // Only descendants of a real clipping layer (i.e., not 0) may have their
     // clip adjusted due to intersecting with an ancestor clip.
     const bool is_clipped = clip_node->parent_id > 0;
     if (!is_clipped) {
+      DCHECK(!clip_node->data.inherit_parent_target_space_clip);
       clip_node->data.combined_clip = clip_node->data.clip;
       continue;
     }
 
     ClipNode* parent_clip_node = clip_tree->parent(clip_node);
     const TransformNode* parent_transform_node =
         transform_tree.Node(parent_clip_node->data.transform_id);
     const TransformNode* transform_node =
         transform_tree.Node(clip_node->data.transform_id);
 
     // Clips must be combined in target space. We cannot, for example, combine
     // clips in the space of the child clip. The reason is non-affine
     // transforms. Say we have the following tree T->A->B->C, and B clips C, but
     // draw into target T. It may be the case that A applies a perspective
     // transform, and B and C are at different z positions. When projected into
     // target space, the relative sizes and positions of B and C can shift.
     // Since it's the relationship in target space that matters, that's where we
     // must combine clips.
     gfx::Transform parent_to_target;
     gfx::Transform clip_to_target;
     gfx::Transform target_to_clip;
+    gfx::Transform parent_to_transform_target;
+    gfx::Transform transform_target_to_target;
 
     const bool target_is_root_surface = clip_node->data.target_id == 1;
     // When the target is the root surface, we need to include the root
     // transform by walking up to the root of the transform tree.
     const int target_id =
         target_is_root_surface ? 0 : clip_node->data.target_id;
 
     bool success = true;
-    if (parent_transform_node->data.content_target_id ==
-        clip_node->data.target_id) {
+    // When render surface applies clip, we need the clip from the target's
+    // target space. But, as the combined clip is in parent clip's target
+    // space, we need to first transform it from parent's target space to
+    // target's target space.
+    if (clip_node->data.inherit_parent_target_space_clip) {
+      success &= transform_tree.ComputeTransformWithDestinationSublayerScale(
+          parent_transform_node->id, transform_node->data.target_id,
+          &parent_to_transform_target);
+      success &= transform_tree.ComputeTransformWithDestinationSublayerScale(
+          transform_node->data.target_id, target_id,
+          &transform_target_to_target);
+    } else if (parent_transform_node->data.content_target_id ==
+               clip_node->data.target_id) {
       parent_to_target = parent_transform_node->data.to_target;
     } else {
       success &= transform_tree.ComputeTransformWithDestinationSublayerScale(
           parent_transform_node->id, target_id, &parent_to_target);
     }
 
     if (transform_node->data.content_target_id == clip_node->data.target_id) {
       clip_to_target = transform_node->data.to_target;
     } else {
       success &= transform_tree.ComputeTransformWithDestinationSublayerScale(
           transform_node->id, target_id, &clip_to_target);
     }
 
     if (transform_node->data.content_target_id == clip_node->data.target_id &&
         transform_node->data.ancestors_are_invertible) {
       target_to_clip = transform_node->data.from_target;
     } else {
       success &= clip_to_target.GetInverse(&target_to_clip);
     }
 
     // If we can't compute a transform, it's because we had to use the inverse
     // of a singular transform. We won't draw in this case, so there's no need
     // to compute clips.
     if (!success)
       continue;
 
     // In order to intersect with as small a rect as possible, we do a
     // preliminary clip in target space so that when we project back, there's
     // less likelihood of intersecting the view plane.
-    gfx::RectF inherited_clip_in_target_space = MathUtil::MapClippedRect(
-        parent_to_target, parent_clip_node->data.combined_clip);
+    gfx::RectF inherited_clip_in_target_space;
+    if (clip_node->data.inherit_parent_target_space_clip &&
+        parent_transform_node->id > transform_node->data.target_id) {
+      gfx::RectF combined_clip_in_transform_target_space =
+          MathUtil::MapClippedRect(parent_to_transform_target,
+                                   parent_clip_node->data.combined_clip);
+      inherited_clip_in_target_space = MathUtil::ProjectClippedRect(
+          transform_target_to_target, combined_clip_in_transform_target_space);
+    } else if (parent_transform_node->id > target_id) {
+      inherited_clip_in_target_space = MathUtil::MapClippedRect(
+          parent_to_target, parent_clip_node->data.combined_clip);
+    } else {
+      inherited_clip_in_target_space = MathUtil::ProjectClippedRect(

[jaydasika, 2015/07/31 17:34:14]

I am not sure if this is ever reached as it did not exist before this patch
though I think it should as it is possible that target is an ancestor of parent.
Should I leave it or delete it?

[ajuma, 2015/07/31 22:41:01]

I think you meant "parent is an ancestor of target" (since the current logic
assumes the target is an ancestor of parent, since it Maps rather than
Projects).

Wouldn't this happen for most clip nodes owned by a render surface? Since in
that case, the target would be the render surface's transform node, and the
parent clip node's transform node would be some ancestor.

Perhaps trying adding a DCHECK that this doesn't happen, and see if it any
layout tests hit it. We can also try to work through an example together next
week.

+          parent_to_target, parent_clip_node->data.combined_clip);
+    }
 
-    gfx::RectF clip_in_target_space =
-        MathUtil::MapClippedRect(clip_to_target, clip_node->data.clip);
+    // When render surface applies clip, the layer that created the clip node
+    // doesn't apply any clip. So, we should clip using the clip value
+    // stored in the clip node.
+    gfx::RectF intersected_in_target_space;
+    if (!clip_node->data.inherit_parent_target_space_clip) {
+      gfx::RectF clip_in_target_space =
+          MathUtil::MapClippedRect(clip_to_target, clip_node->data.clip);
 
-    gfx::RectF intersected_in_target_space = gfx::IntersectRects(
-        inherited_clip_in_target_space, clip_in_target_space);
+      intersected_in_target_space = gfx::IntersectRects(
+          inherited_clip_in_target_space, clip_in_target_space);
+    } else {
+      intersected_in_target_space = inherited_clip_in_target_space;
+    }
 
     clip_node->data.combined_clip = MathUtil::ProjectClippedRect(
         target_to_clip, intersected_in_target_space);
 
-    clip_node->data.combined_clip.Intersect(clip_node->data.clip);
+    if (!clip_node->data.inherit_parent_target_space_clip)
+      clip_node->data.combined_clip.Intersect(clip_node->data.clip);
   }
   clip_tree->set_needs_update(false);
 }
 
 void ComputeTransforms(TransformTree* transform_tree) {
   if (!transform_tree->needs_update())
     return;
   for (int i = 1; i < static_cast<int>(transform_tree->size()); ++i)
     transform_tree->UpdateTransforms(i);
   transform_tree->set_needs_update(false);
@@ skipping 213 matching lines @@
   if (static_cast<int>(layer->offset_to_transform_parent().x()) !=
       layer->offset_to_transform_parent().x())
     return false;
   if (static_cast<int>(layer->offset_to_transform_parent().y()) !=
       layer->offset_to_transform_parent().y())
     return false;
   return true;
 }
 
 }  // namespace cc