Revert of cc : 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 91 matching lines @@
       for_visible_rect_calculation ? clip_node->combined_clip_in_target_space
                                    : clip_node->clip_in_target_space;
 
   if (clip_node->target_transform_id > target_node_id) {
     // In this case, layer has a scroll parent. We need to keep the scale
     // at the layer's target but remove the scale at the scroll parent's
     // target.
     if (property_trees->ComputeTransformToTarget(clip_node->target_transform_id,
                                                  target_effect_node->id,
                                                  &clip_to_target)) {
-      PostConcatSurfaceContentsScale(target_effect_node, &clip_to_target);
+      // We don't have to apply surface contents scale when target is root.
+      if (target_effect_node->id != EffectTree::kContentsRootNodeId) {
+        PostConcatSurfaceContentsScale(target_effect_node, &clip_to_target);
 #if DCHECK_IS_ON()
-      const TransformTree& transform_tree = property_trees->transform_tree;
-      VerifySurfaceContentsScalesMatch(layer->effect_tree_index(),
-                                       target_node_id, effect_tree,
-                                       transform_tree);
+        const TransformTree& transform_tree = property_trees->transform_tree;
+        VerifySurfaceContentsScalesMatch(layer->effect_tree_index(),
+                                         target_node_id, effect_tree,
+                                         transform_tree);
 #endif
+      }
 
       const EffectNode* source_node =
           effect_tree.Node(clip_node->target_effect_id);
       ConcatInverseSurfaceContentsScale(source_node, &clip_to_target);
 #if DCHECK_IS_ON()
+      const TransformTree& transform_tree = property_trees->transform_tree;
       VerifySurfaceContentsScalesMatch(clip_node->target_effect_id,
                                        clip_node->target_transform_id,
                                        effect_tree, transform_tree);
 #endif
       *clip_rect_in_target_space =
           MathUtil::MapClippedRect(clip_to_target, clip_from_clip_node);
     } else {
       return false;
     }
   } else {
@@ skipping 38 matching lines @@
 }
 
 static ConditionalClip ComputeLocalRectInTargetSpace(
     gfx::RectF rect,
     const PropertyTrees* property_trees,
     int current_transform_id,
     int target_transform_id,
     int target_effect_id) {
   gfx::Transform current_to_target;
   if (!property_trees->ComputeTransformToTarget(
-          current_transform_id, target_effect_id, &current_to_target)) {
+          current_transform_id, target_effect_id, &current_to_target))
     // If transform is not invertible, cannot apply clip.
     return ConditionalClip{false, gfx::RectF()};
+  // We don't have to apply surface contents scale when target is root.
+  if (target_effect_id != EffectTree::kContentsRootNodeId) {
+    const EffectTree& effect_tree = property_trees->effect_tree;
+    const EffectNode* target_effect_node = effect_tree.Node(target_effect_id);
+    PostConcatSurfaceContentsScale(target_effect_node, &current_to_target);
+#if DCHECK_IS_ON()
+    const TransformTree& transform_tree = property_trees->transform_tree;
+    VerifySurfaceContentsScalesMatch(target_effect_id, target_transform_id,
+                                     effect_tree, transform_tree);
+#endif
   }
-  const EffectTree& effect_tree = property_trees->effect_tree;
-  const EffectNode* target_effect_node = effect_tree.Node(target_effect_id);
-  PostConcatSurfaceContentsScale(target_effect_node, &current_to_target);
-#if DCHECK_IS_ON()
-  const TransformTree& transform_tree = property_trees->transform_tree;
-  VerifySurfaceContentsScalesMatch(target_effect_id, target_transform_id,
-                                   effect_tree, transform_tree);
-#endif
 
   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 PropertyTrees* property_trees,
                                           int target_transform_id,
                                           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;
-  // The viewport clip should not be scaled
-  if (surface_contents_scale.x() > 0 && surface_contents_scale.y() > 0 &&
-      clip_node->transform_id != TransformTree::kRootNodeId)
+  if (surface_contents_scale.x() > 0 && surface_contents_scale.y() > 0)
     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,
     int local_clip_id,
     int target_id) {
   const ClipTree& clip_tree = property_trees->clip_tree;
   const EffectTree& effect_tree = property_trees->effect_tree;
@@ skipping 300 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;
       }
-      ConcatInverseSurfaceContentsScale(target_effect_node, &target_to_layer);
+      if (target_effect_node->id > EffectTree::kContentsRootNodeId) {
+        ConcatInverseSurfaceContentsScale(target_effect_node, &target_to_layer);
 #if DCHECK_IS_ON()
-      VerifySurfaceContentsScalesMatch(target_effect_node->id, target_node_id,
-                                       effect_tree, transform_tree);
+        VerifySurfaceContentsScalesMatch(target_effect_node->id, target_node_id,
+                                         effect_tree, transform_tree);
 #endif
+      }
     }
     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 258 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);
-      const EffectNode* target_effect_node =
-          effect_tree.Node(clip_node->target_effect_id);
-      PostConcatSurfaceContentsScale(target_effect_node, &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 DCHECK_IS_ON()
-      VerifySurfaceContentsScalesMatch(clip_node->target_effect_id,
-                                       clip_node->target_transform_id,
-                                       effect_tree, transform_tree);
+        VerifySurfaceContentsScalesMatch(clip_node->target_effect_id,
+                                         clip_node->target_transform_id,
+                                         effect_tree, transform_tree);
 #endif
-      const EffectNode* parent_target_effect_node =
-          effect_tree.Node(parent_clip_node->target_effect_id);
-      ConcatInverseSurfaceContentsScale(parent_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);
 #if DCHECK_IS_ON()
-      VerifySurfaceContentsScalesMatch(parent_clip_node->target_effect_id,
-                                       parent_clip_node->target_transform_id,
-                                       effect_tree, transform_tree);
+        VerifySurfaceContentsScalesMatch(parent_clip_node->target_effect_id,
+                                         parent_clip_node->target_transform_id,
+                                         effect_tree, transform_tree);
 #endif
+      }
       // 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 41 matching lines @@
 
       if (!non_root_surfaces_enabled) {
         source_to_target = transform_tree.ToScreen(clip_node->transform_id);
       } else if (transform_tree.ContentTargetId(transform_node->id) ==
                  clip_node->target_transform_id) {
         source_to_target = transform_tree.ToTarget(clip_node->transform_id,
                                                    clip_node->target_effect_id);
       } else {
         success = property_trees->ComputeTransformToTarget(
             transform_node->id, clip_node->target_effect_id, &source_to_target);
-        const EffectNode* target_effect_node =
-            effect_tree.Node(clip_node->target_effect_id);
-        PostConcatSurfaceContentsScale(target_effect_node, &source_to_target);
+        // 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, &source_to_target);
 #if DCHECK_IS_ON()
-        VerifySurfaceContentsScalesMatch(clip_node->target_effect_id,
-                                         clip_node->target_transform_id,
-                                         effect_tree, transform_tree);
+          VerifySurfaceContentsScalesMatch(clip_node->target_effect_id,
+                                           clip_node->target_transform_id,
+                                           effect_tree, transform_tree);
 #endif
+        }
         // source_to_target computation should be successful as target is an
         // ancestor of the transform node.
         DCHECK(success);
       }
 
       gfx::RectF source_clip_in_target_space =
           MathUtil::MapClippedRect(source_to_target, clip_node->clip);
 
       // 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
@@ skipping 24 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 node corresponding to root is itself.
-      node->target_id = 1;
+      // Render target on the first effect node is root.
+      node->target_id = 0;
     } 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 84 matching lines @@
 static void VerifyDrawTransformsMatch(LayerImpl* layer,
                                       PropertyTrees* property_trees) {
   const int source_id = layer->transform_tree_index();
   int destination_id = FindTargetTransformTreeIndexFromEffectTree(
       property_trees->effect_tree, layer->effect_tree_index());
   const EffectNode* target_effect_node = ContentsTargetEffectNode(
       layer->effect_tree_index(), property_trees->effect_tree);
   gfx::Transform draw_transform;
   property_trees->ComputeTransformToTarget(source_id, target_effect_node->id,
                                            &draw_transform);
-  PostConcatSurfaceContentsScale(target_effect_node, &draw_transform);
+  // We don't have to apply surface contents scale when target is root.
+  if (target_effect_node->id != EffectTree::kContentsRootNodeId) {
+    PostConcatSurfaceContentsScale(target_effect_node, &draw_transform);
 #if DCHECK_IS_ON()
-  VerifySurfaceContentsScalesMatch(layer->effect_tree_index(), destination_id,
-                                   property_trees->effect_tree,
-                                   property_trees->transform_tree);
+    VerifySurfaceContentsScalesMatch(layer->effect_tree_index(), destination_id,
+                                     property_trees->effect_tree,
+                                     property_trees->transform_tree);
 #endif
+  }
   if (layer->should_flatten_transform_from_property_tree())
     draw_transform.FlattenTo2d();
   draw_transform.Translate(layer->offset_to_transform_parent().x(),
                            layer->offset_to_transform_parent().y());
   DCHECK(draw_transform.ApproximatelyEqual(DrawTransform(
       layer, property_trees->transform_tree, property_trees->effect_tree)))
       << " layer: " << layer->id() << " source transform id: " << source_id
       << " destination transform id: " << destination_id
       << " draw transform from transform tree: "
       << DrawTransform(layer, property_trees->transform_tree,
@@ skipping 221 matching lines @@
   if (transform_node->id == 1) {
     render_surface->SetDrawTransform(gfx::Transform());
     return;
   }
 
   gfx::Transform render_surface_transform;
   const EffectNode* target_effect_node =
       effect_tree.Node(effect_node->target_id);
   property_trees->ComputeTransformToTarget(
       transform_node->id, target_effect_node->id, &render_surface_transform);
-  PostConcatSurfaceContentsScale(target_effect_node, &render_surface_transform);
+  // We don't have to apply surface contents scale when target is root.
+  if (effect_node->target_id != EffectTree::kContentsRootNodeId) {
+    PostConcatSurfaceContentsScale(target_effect_node,
+                                   &render_surface_transform);
 #if DCHECK_IS_ON()
-  const TransformNode* target_transform_node =
-      transform_tree.Node(transform_tree.TargetId(transform_node->id));
-  VerifySurfaceContentsScalesMatch(effect_node->target_id,
-                                   target_transform_node->id, effect_tree,
-                                   transform_tree);
+    const TransformNode* target_transform_node =
+        transform_tree.Node(transform_tree.TargetId(transform_node->id));
+    VerifySurfaceContentsScalesMatch(effect_node->target_id,
+                                     target_transform_node->id, effect_tree,
+                                     transform_tree);
 #endif
+  }
 
   ConcatInverseSurfaceContentsScale(effect_node, &render_surface_transform);
 #if DCHECK_IS_ON()
   VerifySurfaceContentsScalesMatch(effect_node->id, transform_node->id,
                                    effect_tree, transform_tree);
 #endif
   render_surface->SetDrawTransform(render_surface_transform);
 }
 
 static void SetSurfaceIsClipped(const ClipNode* clip_node,
@@ skipping 32 matching lines @@
   int target_effect_id = effect_node->target_id;
   const bool success = property_trees->ComputeTransformToTarget(
       parent_clip_node->target_transform_id, target_effect_id,
       &clip_parent_target_to_target);
 
   if (!success) {
     render_surface->SetClipRect(gfx::Rect());
     return;
   }
 
-  PostConcatSurfaceContentsScale(effect_node, &clip_parent_target_to_target);
+  // We don't have to apply surface contents scale when target is root.
+  if (render_surface->EffectTreeIndex() != EffectTree::kContentsRootNodeId) {
+    const EffectNode* effect_node =
+        effect_tree.Node(render_surface->EffectTreeIndex());
+    PostConcatSurfaceContentsScale(effect_node, &clip_parent_target_to_target);
 #if DCHECK_IS_ON()
-  VerifySurfaceContentsScalesMatch(render_surface->EffectTreeIndex(),
-                                   transform_tree.TargetId(transform_node->id),
-                                   effect_tree, transform_tree);
+    VerifySurfaceContentsScalesMatch(
+        render_surface->EffectTreeIndex(),
+        transform_tree.TargetId(transform_node->id), effect_tree,
+        transform_tree);
 #endif
+  }
 
   DCHECK_LT(parent_clip_node->target_transform_id,
             transform_tree.TargetId(transform_node->id));
   render_surface->SetClipRect(gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
       clip_parent_target_to_target, parent_clip_node->clip_in_target_space)));
 }
 
 template <typename LayerType>
 static gfx::Transform ScreenSpaceTransformInternal(LayerType* layer,
                                                    const TransformTree& tree) {
@@ skipping 211 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