cc: Fix non root copy request visible rect in HighDPI

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 79 matching lines @@
     }
   }
   return true;
 }
 
 struct ConditionalClip {
   bool is_clipped;
   gfx::RectF clip_rect;
 };
 
-static ConditionalClip ComputeRectInTargetSpace(
+static ConditionalClip ComputeTargetRectInLocalSpace(
     gfx::RectF rect,
     const TransformTree& transform_tree,
     int current_transform_id,
+    int target_transform_id) {
+  gfx::Transform current_to_target;
+  if (!transform_tree.ComputeTransformWithSourceSublayerScale(
+          current_transform_id, target_transform_id, &current_to_target))
+    // If transform is not invertible, cannot apply clip.
+    return ConditionalClip{false, gfx::RectF()};
+
+  if (current_transform_id > target_transform_id)
+    return ConditionalClip{true,  // is_clipped.
+                           MathUtil::MapClippedRect(current_to_target, rect)};
+
+  return ConditionalClip{true,  // is_clipped.
+                         MathUtil::ProjectClippedRect(current_to_target, rect)};
+}
+
+static ConditionalClip ComputeLocalRectInTargetSpace(
+    gfx::RectF rect,
+    const TransformTree& transform_tree,
+    int current_transform_id,
     int target_transform_id) {
   gfx::Transform current_to_target;
   if (!transform_tree.ComputeTransformWithDestinationSublayerScale(
           current_transform_id, target_transform_id, &current_to_target))
     // If transform is not invertible, cannot apply clip.
     return ConditionalClip{false, gfx::RectF()};
+
   if (current_transform_id > target_transform_id)
     return ConditionalClip{true,  // is_clipped.
                            MathUtil::MapClippedRect(current_to_target, rect)};
 
   return ConditionalClip{true,  // is_clipped.
                          MathUtil::ProjectClippedRect(current_to_target, rect)};
 }
 
 static ConditionalClip ComputeCurrentClip(const ClipNode* clip_node,
                                           const TransformTree& transform_tree,
                                           int target_transform_id) {
   if (clip_node->data.transform_id != target_transform_id)
-    return ComputeRectInTargetSpace(clip_node->data.clip, transform_tree,
-                                    clip_node->data.transform_id,
-                                    target_transform_id);
+    return ComputeLocalRectInTargetSpace(clip_node->data.clip, transform_tree,
+                                         clip_node->data.transform_id,
+                                         target_transform_id);
 
   gfx::RectF current_clip = clip_node->data.clip;
   gfx::Vector2dF sublayer_scale =
       transform_tree.Node(target_transform_id)->data.sublayer_scale;
   if (sublayer_scale.x() > 0 && sublayer_scale.y() > 0)
     current_clip.Scale(sublayer_scale.x(), sublayer_scale.y());
   return ConditionalClip{true /* is_clipped */, current_clip};
 }
 
 static ConditionalClip ComputeAccumulatedClip(
@@ skipping 166 matching lines @@
       if (!accumulated_clip_rect.is_clipped) {
         layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
         continue;
       }
 
       gfx::RectF accumulated_clip_in_copy_request_space =
           accumulated_clip_rect.clip_rect;
 
       const EffectNode* copy_request_effect_node =
           effect_tree.Node(effect_ancestor_with_copy_request);
-      ConditionalClip clip_in_layer_space = ComputeRectInTargetSpace(
+      ConditionalClip clip_in_layer_space = ComputeTargetRectInLocalSpace(
           accumulated_clip_in_copy_request_space, transform_tree,
           copy_request_effect_node->data.transform_id,
           layer->transform_tree_index());
+
       if (clip_in_layer_space.is_clipped) {
         gfx::RectF clip_rect = clip_in_layer_space.clip_rect;
         clip_rect.Offset(-layer->offset_to_transform_parent());
         gfx::Rect visible_rect = gfx::ToEnclosingRect(clip_rect);
         visible_rect.Intersect(gfx::Rect(layer_bounds));
         layer->set_visible_layer_rect(visible_rect);
       } else {
         layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
       }
       continue;
@@ skipping 1040 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