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 399 matching lines @@
     gfx::Transform clip_to_target;
     gfx::Transform target_to_clip;
 
     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) {
+    if (clip_node->data.render_surface_applies_clip) {
+      success &= transform_tree.ComputeTransform(transform_node->data.target_id,
+                                                 target_id, &parent_to_target);

[ajuma, 2015/07/29 16:44:29]

I'm having trouble following this. parent_to_target used to be the
transformation from the parent transform node to the target node (so, in the
example given in the comment above, it would be the transform from A to T). But
here it's the transform from the transform node's render surface to the target
(and, depending on the transform tree, the transform node's render surface might
be the same as target, or might be the target's target). I'd have expected this
change to also require a change below (where we use parent_to_target to
transform the parent_clip_node's combined_clip from parent space to target
space).

[jaydasika, 2015/07/30 19:43:10]

Done.

+    } 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 (parent_transform_node->id > target_id &&

[ajuma, 2015/07/29 16:44:29]

We weren't previously handling the case where parent_transform_node->id <
target_id, so that was itself probably causing bugs.

Please add (at least) two test cases to layer_tree_host_common_unittest.cc
showing what this change fixes: one where we have parent_transform_node->id <
target_id, and another where we have render_surface_applies_clip.

[jaydasika, 2015/07/30 19:43:10]

Add a unit test where render surface applies clip. I am not sure if the other
case ever occurs.

+        !clip_node->data.render_surface_applies_clip)
+      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);
 
     gfx::RectF intersected_in_target_space = gfx::IntersectRects(
         inherited_clip_in_target_space, clip_in_target_space);
 
     clip_node->data.combined_clip = MathUtil::ProjectClippedRect(
         target_to_clip, intersected_in_target_space);
 
@@ skipping 224 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