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

cc/trees/property_tree.cc

Index: cc/trees/property_tree.cc
diff --git a/cc/trees/property_tree.cc b/cc/trees/property_tree.cc
index 4f2c950bf333125e0f3a0e44fd03ab079242d0e8..ce0a5679dc5a7b748a89e1ec42037e268c151c0d 100644
--- a/cc/trees/property_tree.cc
+++ b/cc/trees/property_tree.cc
@@ -668,65 +668,30 @@ void TransformTree::UpdateNodeAndAncestorsAreAnimatedOrInvertible(
       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());
-
-  TransformNode* node = Node(kContentsRootNodeId);
-  if (node->post_local == post_local)
+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;
-  node->post_local = 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);
-  gfx::Transform to_screen;
-  to_screen.Scale(screen_space_scale_components.x(),
-                  screen_space_scale_components.y());
-  if (ToScreen(node->id) == to_screen)
-    return;
-  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);
+  node->post_local = root_post_local;
+  node->needs_local_transform_update = true;
   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() {
@@ -987,7 +952,8 @@ void EffectTree::UpdateBackfaceVisibility(EffectNode* node,
 }
 
 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;
   }
@@ -2212,9 +2178,10 @@ DrawTransforms& PropertyTrees::GetDrawTransforms(int transform_id,
   } else if (transform_id > dest_id) {
     transform_tree.CombineTransformsBetween(transform_id, dest_id,
                                             &target_space_transform);
-    target_space_transform.matrix().postScale(
-        effect_node->surface_contents_scale.x(),
-        effect_node->surface_contents_scale.y(), 1.f);
+    if (dest_id != TransformTree::kRootNodeId)
+      target_space_transform.matrix().postScale(
+          effect_node->surface_contents_scale.x(),
+          effect_node->surface_contents_scale.y(), 1.f);
     data.transforms.to_valid = true;
     data.transforms.from_valid = false;
     data.transforms.might_be_invertible = true;