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 39 matching lines @@
 
       gfx::Rect clip_rect_in_target_space;
       gfx::Transform clip_to_target;
       bool success = true;
       if (clip_transform_node->data.target_id == target_node->id) {
         clip_to_target = clip_transform_node->data.to_target;
       } else {
         success = transform_tree.ComputeTransformWithDestinationSublayerScale(
             clip_transform_node->id, target_node->id, &clip_to_target);
       }
-
       if (target_node->id > clip_node->data.transform_id) {
         if (!success) {
           DCHECK(target_node->data.to_screen_is_animated);
 
           // An animated singular transform may become non-singular during the
           // animation, so we still need to compute a visible rect. In this
           // situation, we treat the entire layer as visible.
           layer->set_visible_rect_from_property_trees(gfx::Rect(layer_bounds));
           continue;
         }
@@ skipping 310 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)
+    if (!success) {
+      if (clip_node->data.inherit_parent_target_space_clip) {
+        clip_node->data.transform_id = parent_clip_node->data.transform_id;

[ajuma, 2015/08/05 13:51:09]

I don't think we should be changing the transform id here -- that should only
change during tree building. Otherwise, suppose the value of the transform
that's currently uninvertible changes on the next frame, such that it becomes
invertible. If we've changed the transform_id here, we're going to do the wrong
thing, I think.

[jaydasika, 2015/08/05 15:07:20]

Ah, I see the problem. But I am still not sure what the alternative is?

[ajuma, 2015/08/05 15:21:58]

If we reach this point, we have an uninvertible transform, so we just need to
have some reasonable fallback. For example, there are places where CDP pretends
that an uninvertible transform's inverse is the identity. I think the equivalent
here might be to set the combined clip as you do on the next line, but leave the
transform id as-is.

[jaydasika, 2015/08/05 21:50:11]

Done.

+        clip_node->data.combined_clip = parent_clip_node->data.combined_clip;
+      } else {
+        clip_node->data.combined_clip = clip_node->data.clip;
+      }
       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) {
+      gfx::RectF combined_clip_in_transform_target_space;
+      if (parent_transform_node->id > transform_node->data.target_id)
+        combined_clip_in_transform_target_space = MathUtil::MapClippedRect(
+            parent_to_transform_target, parent_clip_node->data.combined_clip);
+      else
+        combined_clip_in_transform_target_space = MathUtil::ProjectClippedRect(
+            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(
+          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