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 312 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.ComputeTransformWithSourceSublayerScale(
+          transform_node->data.target_id, target_id,
+          &transform_target_to_target);
+      transform_target_to_target.matrix().postScale(
+          transform_node->data.sublayer_scale.x(),
+          transform_node->data.sublayer_scale.y(), 1.0);
+    } 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) {
       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 inherits its parent target space clip, the layer
+    // that created the clip node doesn't apply any clip. So, we shouldn't 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 232 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