cc : Fix sublayer scale bug when there is a transform node b/w targets

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 542 matching lines @@
       ResetIfHasNanCoordinate(&clip_node->data.clip);
       clip_node->data.clip_in_target_space = clip_node->data.clip;
       clip_node->data.combined_clip_in_target_space = clip_node->data.clip;
       continue;
     }
     const TransformNode* transform_node =
         transform_tree.Node(clip_node->data.transform_id);
     ClipNode* parent_clip_node = clip_tree->parent(clip_node);
 
     gfx::Transform parent_to_current;
-    const TransformNode* parent_transform_node =
-        transform_tree.Node(parent_clip_node->data.transform_id);
+    const TransformNode* parent_target_transform_node =
+        transform_tree.Node(parent_clip_node->data.target_id);
     bool success = true;
 
     // 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. 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 &&
+    if (parent_target_transform_node &&
+        parent_target_transform_node->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_target_transform_node->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)
+      if (parent_target_transform_node->data.sublayer_scale.x() > 0 &&
+          parent_target_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());
+            1.f / parent_target_transform_node->data.sublayer_scale.x(),
+            1.f / parent_target_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);
@@ skipping 575 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