Revert of cc : Move screen space scale factor to root transform node

cc/trees/property_tree.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 <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 589 matching lines @@
   gfx::Transform target_space_transform;
   if (node->needs_surface_contents_scale) {
     target_space_transform.MakeIdentity();
     target_space_transform.Scale(node->surface_contents_scale.x(),
                                  node->surface_contents_scale.y());
   } else {
     // In order to include the root transform for the root surface, we walk up
     // to the root of the transform tree in ComputeTransform.
     int target_id = target_node->id;
     ComputeTransform(node->id, target_id, &target_space_transform);
-    target_space_transform.matrix().postScale(
-        target_node->surface_contents_scale.x(),
-        target_node->surface_contents_scale.y(), 1.f);
+    if (target_id != kRootNodeId) {
+      target_space_transform.matrix().postScale(
+          target_node->surface_contents_scale.x(),
+          target_node->surface_contents_scale.y(), 1.f);
+    }
   }
 
   gfx::Transform from_target;
   if (!target_space_transform.GetInverse(&from_target))
     node->ancestors_are_invertible = false;
   SetToTarget(node->id, target_space_transform);
   SetFromTarget(node->id, from_target);
 }
 
 void TransformTree::UpdateAnimationProperties(TransformNode* node,
@@ skipping 73 matching lines @@
   bool is_invertible = node->is_invertible;
   // Even when the current node's transform and the parent's screen space
   // transform are invertible, the current node's screen space transform can
   // become uninvertible due to floating-point arithmetic.
   if (!node->ancestors_are_invertible && parent_node->ancestors_are_invertible)
     is_invertible = false;
   node->node_and_ancestors_are_animated_or_invertible =
       node->has_potential_animation || is_invertible;
 }
 
-void TransformTree::SetContentsRootPostLocalTransform(
-    const gfx::Transform& transform,
-    gfx::PointF root_position) {
-  // The post local transform of the contents root node is set to the device
-  // transform with scale removed and is also offset by the root layer's
-  // position. The scale part of the device transform goes into the screen space
-  // scale stored on the root node.
-  gfx::Transform post_local = transform;
-  post_local.Translate(root_position.x(), root_position.y());
+void TransformTree::SetDeviceTransform(const gfx::Transform& transform,
+                                       gfx::PointF root_position) {
+  gfx::Transform root_post_local = transform;
+  TransformNode* node = Node(1);
+  root_post_local.Scale(node->post_local_scale_factor,
+                        node->post_local_scale_factor);
+  root_post_local.Translate(root_position.x(), root_position.y());
+  if (node->post_local == root_post_local)
+    return;
 
-  TransformNode* node = Node(kContentsRootNodeId);
-  if (node->post_local == post_local)
-    return;
-  node->post_local = post_local;
+  node->post_local = root_post_local;
   node->needs_local_transform_update = true;
   set_needs_update(true);
 }
 
-void TransformTree::SetScreenSpaceScaleOnRootNode(
-    gfx::Vector2dF screen_space_scale_components) {
-  TransformNode* node = Node(kRootNodeId);
-  if (node->surface_contents_scale == screen_space_scale_components)
-    return;
-  node->needs_surface_contents_scale = true;
-  node->surface_contents_scale = screen_space_scale_components;
-  gfx::Transform to_screen;
-  to_screen.Scale(node->surface_contents_scale.x(),
-                  node->surface_contents_scale.y());
-  SetToScreen(node->id, to_screen);
-  gfx::Transform from_screen;
-  if (!ToScreen(node->id).GetInverse(&from_screen))
-    node->ancestors_are_invertible = false;
-  SetFromScreen(node->id, from_screen);
-  set_needs_update(true);
-}
-
-void TransformTree::SetRootTransformsAndScales(
-    float device_scale_factor,
-    float page_scale_factor_for_root,
-    const gfx::Transform& device_transform,
-    gfx::PointF root_position) {
+void TransformTree::SetDeviceTransformScaleFactor(
+    const gfx::Transform& transform) {
   gfx::Vector2dF device_transform_scale_components =
-      MathUtil::ComputeTransform2dScaleComponents(device_transform, 1.f);
+      MathUtil::ComputeTransform2dScaleComponents(transform, 1.f);
 
   // Not handling the rare case of different x and y device scale.
   device_transform_scale_factor_ =
       std::max(device_transform_scale_components.x(),
                device_transform_scale_components.y());
-  gfx::Transform device_transform_without_scale = device_transform;
-  device_transform_without_scale.matrix().postScale(
-      1.f / device_transform_scale_components.x(),
-      1.f / device_transform_scale_components.y(), 1.f);
-  SetContentsRootPostLocalTransform(device_transform_without_scale,
-                                    root_position);
-
-  gfx::Vector2dF screen_space_scale_components(
-      device_transform_scale_components.x() * device_scale_factor *
-          page_scale_factor_for_root,
-      device_transform_scale_components.y() * device_scale_factor *
-          page_scale_factor_for_root);
-  SetScreenSpaceScaleOnRootNode(screen_space_scale_components);
 }
 
 void TransformTree::UpdateInnerViewportContainerBoundsDelta() {
   if (nodes_affected_by_inner_viewport_bounds_delta_.empty())
     return;
 
   set_needs_update(true);
   for (int i : nodes_affected_by_inner_viewport_bounds_delta_)
     Node(i)->needs_local_transform_update = true;
 }
@@ skipping 278 matching lines @@
               transform_node->local.IsBackFaceVisible();
         }
         return;
       }
     }
   }
   node->hidden_by_backface_visibility = false;
 }
 
 void EffectTree::UpdateSurfaceContentsScale(EffectNode* effect_node) {
-  if (!effect_node->has_render_surface) {
+  if (!effect_node->has_render_surface ||
+      effect_node->transform_id == kRootNodeId) {
     effect_node->surface_contents_scale = gfx::Vector2dF(1.0f, 1.0f);
     return;
   }
 
   TransformTree& transform_tree = property_trees()->transform_tree;
   float layer_scale_factor = transform_tree.device_scale_factor() *
                              transform_tree.device_transform_scale_factor();
   TransformNode* transform_node =
       transform_tree.Node(effect_node->transform_id);
   if (transform_node->in_subtree_of_page_scale_layer)
@@ skipping 99 matching lines @@
     } else {
       // The root surface doesn't have the notion of sub-layer scale, but
       // instead has a similar notion of transforming from the space of the root
       // layer to the space of the screen.
       DCHECK_EQ(kRootNodeId, destination_id);
       source_id = TransformTree::kContentsRootNodeId;
     }
     gfx::Transform transform;
     property_trees()->transform_tree.ComputeTransform(source_id, destination_id,
                                                       &transform);
-    transform.matrix().postScale(effect_node->surface_contents_scale.x(),
-                                 effect_node->surface_contents_scale.y(), 1.f);
+    if (effect_node->id != kContentsRootNodeId) {
+      transform.matrix().postScale(effect_node->surface_contents_scale.x(),
+                                   effect_node->surface_contents_scale.y(),
+                                   1.f);
+    }
     it->set_area(MathUtil::MapEnclosingClippedRect(transform, it->area()));
   }
 }
 
 bool EffectTree::HasCopyRequests() const {
   return !copy_requests_.empty();
 }
 
 void EffectTree::ClearCopyRequests() {
   for (auto& node : nodes()) {
@@ skipping 1199 matching lines @@
     from_target.ConcatTransform(draw_transforms.from_target);
     from_target.Scale(effect_node->surface_contents_scale.x(),
                       effect_node->surface_contents_scale.y());
     DCHECK(from_target.ApproximatelyEqual(*transform) ||
            !draw_transforms.invertible);
   }
   return success;
 }
 
 }  // namespace cc