cc : Reland move screen space scale factor to root transform node

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 153 matching lines @@
                                           int target_effect_id) {
   if (clip_node->transform_id != target_transform_id)
     return ComputeLocalRectInTargetSpace(clip_node->clip, property_trees,
                                          clip_node->transform_id,
                                          target_transform_id, target_effect_id);
 
   const EffectTree& effect_tree = property_trees->effect_tree;
   gfx::RectF current_clip = clip_node->clip;
   gfx::Vector2dF surface_contents_scale =
       effect_tree.Node(target_effect_id)->surface_contents_scale;
-  if (surface_contents_scale.x() > 0 && surface_contents_scale.y() > 0)
+  // The viewport clip should not be scaled.
+  if (surface_contents_scale.x() > 0 && surface_contents_scale.y() > 0 &&
+      clip_node->transform_id != TransformTree::kRootNodeId)
     current_clip.Scale(surface_contents_scale.x(), surface_contents_scale.y());
   return ConditionalClip{true /* is_clipped */, current_clip};
 }
 
 static ConditionalClip ComputeAccumulatedClip(
     const PropertyTrees* property_trees,
     bool include_viewport_clip,
     int local_clip_id,
     int target_id) {
   DCHECK(!include_viewport_clip ||
@@ skipping 297 matching lines @@
           ContentsTargetEffectNode(layer->effect_tree_index(), effect_tree);
       bool success = property_trees->ComputeTransformFromTarget(
           transform_node->id, target_effect_node->id, &target_to_layer);
       if (!success) {
         // 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_layer_rect(gfx::Rect(layer_bounds));
         continue;
       }
-      if (target_effect_node->id > EffectTree::kContentsRootNodeId)
-        ConcatInverseSurfaceContentsScale(target_effect_node, &target_to_layer);
+      ConcatInverseSurfaceContentsScale(target_effect_node, &target_to_layer);
     }
     gfx::Transform target_to_content;
     target_to_content.Translate(-layer->offset_to_transform_parent().x(),
                                 -layer->offset_to_transform_parent().y());
     target_to_content.PreconcatTransform(target_to_layer);
 
     gfx::Rect visible_rect = gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
         target_to_content, combined_clip_rect_in_target_space));
     visible_rect.Intersect(gfx::Rect(layer_bounds));
     layer->set_visible_layer_rect(visible_rect);
@@ skipping 267 matching lines @@
     gfx::RectF parent_combined_clip_in_target_space =
         parent_clip_node->combined_clip_in_target_space;
     gfx::RectF parent_clip_in_target_space =
         parent_clip_node->clip_in_target_space;
     if (parent_target_transform_node &&
         parent_target_transform_node->id != clip_node->target_transform_id &&
         non_root_surfaces_enabled) {
       success &= property_trees->ComputeTransformFromTarget(
           clip_node->target_transform_id, parent_clip_node->target_effect_id,
           &parent_to_current);
-      // We don't have to apply surface contents scale when target is root.
-      if (clip_node->target_effect_id != EffectTree::kContentsRootNodeId) {
-        const EffectNode* target_effect_node =
-            effect_tree.Node(clip_node->target_effect_id);
-        PostConcatSurfaceContentsScale(target_effect_node, &parent_to_current);
-      }
-      if (parent_clip_node->target_effect_id !=
-          EffectTree::kContentsRootNodeId) {
-        const EffectNode* parent_target_effect_node =
-            effect_tree.Node(parent_clip_node->target_effect_id);
-        ConcatInverseSurfaceContentsScale(parent_target_effect_node,
-                                          &parent_to_current);
-      }
+      const EffectNode* target_effect_node =
+          effect_tree.Node(clip_node->target_effect_id);
+      PostConcatSurfaceContentsScale(target_effect_node, &parent_to_current);
+      const EffectNode* parent_target_effect_node =
+          effect_tree.Node(parent_clip_node->target_effect_id);
+      ConcatInverseSurfaceContentsScale(parent_target_effect_node,
+                                        &parent_to_current);
       // 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->combined_clip_in_target_space);
       parent_clip_in_target_space = MathUtil::ProjectClippedRect(
           parent_to_current, parent_clip_node->clip_in_target_space);
     }
@@ skipping 88 matching lines @@
   for (int i = 1; i < static_cast<int>(transform_tree->size()); ++i)
     transform_tree->UpdateTransforms(i);
   transform_tree->set_needs_update(false);
 }
 
 void UpdateRenderTarget(EffectTree* effect_tree,
                         bool can_render_to_separate_surface) {
   for (int i = 1; i < static_cast<int>(effect_tree->size()); ++i) {
     EffectNode* node = effect_tree->Node(i);
     if (i == 1) {
-      // Render target on the first effect node is root.
-      node->target_id = 0;
+      // Render target of the node corresponding to root is itself.
+      node->target_id = 1;
     } else if (!can_render_to_separate_surface) {
       node->target_id = 1;
     } else if (effect_tree->parent(node)->has_render_surface) {
       node->target_id = node->parent_id;
     } else {
       node->target_id = effect_tree->parent(node)->target_id;
     }
   }
 }
 
@@ skipping 553 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