cc: Correctly inherit clip parent's clip in target space

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 512 matching lines @@
     // 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. For each clip node, we save the clip rects in its
     // target space. So, we need to get the ancestor clip rect in the current
     // clip node's target space.
     gfx::RectF parent_combined_clip_in_target_space =
         parent_clip_node->data.combined_clip_in_target_space;
+    gfx::RectF parent_clip_in_target_space =
+        parent_clip_node->data.clip_in_target_space;
     if (parent_clip_node->data.target_id != clip_node->data.target_id &&
         non_root_surfaces_enabled) {
       success &= transform_tree.ComputeTransformWithDestinationSublayerScale(
           parent_clip_node->data.target_id, clip_node->data.target_id,
           &parent_to_current);
       if (parent_transform_node->data.sublayer_scale.x() > 0 &&
           parent_transform_node->data.sublayer_scale.y() > 0)
         parent_to_current.Scale(
             1.f / parent_transform_node->data.sublayer_scale.x(),
             1.f / parent_transform_node->data.sublayer_scale.y());
       // 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;
       parent_combined_clip_in_target_space = MathUtil::ProjectClippedRect(
           parent_to_current,
           parent_clip_node->data.combined_clip_in_target_space);
+      parent_clip_in_target_space = MathUtil::ProjectClippedRect(
+          parent_to_current, parent_clip_node->data.clip_in_target_space);
     }
     // Only nodes affected by ancestor clips will have their clip adjusted due
     // to intersecting with an ancestor clip. But, we still need to propagate
     // the combined clip to our children because if they are clipped, they may
     // need to clip using our parent clip and if we don't propagate it here,
     // it will be lost.
     if (clip_node->data.resets_clip && non_root_surfaces_enabled) {
       if (clip_node->data.applies_local_clip) {
         clip_node->data.clip_in_target_space = MathUtil::MapClippedRect(
             transform_node->data.to_target, clip_node->data.clip);
@@ skipping 11 matching lines @@
       continue;
     }
     bool use_only_parent_clip = !clip_node->data.applies_local_clip;
     if (use_only_parent_clip) {
       clip_node->data.combined_clip_in_target_space =
           parent_combined_clip_in_target_space;
       if (!non_root_surfaces_enabled) {
         clip_node->data.clip_in_target_space =
             parent_clip_node->data.clip_in_target_space;
       } else if (!clip_node->data.target_is_clipped) {
-        clip_node->data.clip_in_target_space =
-            parent_combined_clip_in_target_space;
+        clip_node->data.clip_in_target_space = parent_clip_in_target_space;
       } else {
         // Render Surface applies clip and the owning layer itself applies
         // no clip. So, clip_in_target_space is not used and hence we can set
         // it to an empty rect.
         clip_node->data.clip_in_target_space = gfx::RectF();
       }
     } else {
       gfx::Transform source_to_target;
 
       if (!non_root_surfaces_enabled) {
@@ skipping 14 matching lines @@
 
       // With surfaces disabled, the only case where we use only the local clip
       // for layer clipping is the case where no non-viewport ancestor node
       // applies a local clip.
       bool layer_clipping_uses_only_local_clip =
           non_root_surfaces_enabled
               ? clip_node->data.layer_clipping_uses_only_local_clip
               : !parent_clip_node->data
                      .layers_are_clipped_when_surfaces_disabled;
       if (!layer_clipping_uses_only_local_clip) {
-        gfx::RectF parent_clip_in_target_space = MathUtil::ProjectClippedRect(
-            parent_to_current, parent_clip_node->data.clip_in_target_space);
         clip_node->data.clip_in_target_space = gfx::IntersectRects(
             parent_clip_in_target_space, source_clip_in_target_space);
       } else {
         clip_node->data.clip_in_target_space = source_clip_in_target_space;
       }
 
       clip_node->data.combined_clip_in_target_space = gfx::IntersectRects(
           parent_combined_clip_in_target_space, source_clip_in_target_space);
     }
     ResetIfHasNanCoordinate(&clip_node->data.clip_in_target_space);
@@ skipping 497 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