cc: Fix property tree position updates when rebuilding is skipped

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 <set>
 #include <vector>
 
 #include "base/logging.h"
 #include "cc/base/math_util.h"
 #include "cc/trees/property_tree.h"
@@ skipping 30 matching lines @@
   back()->parent_id = -1;
 }
 
 template class PropertyTree<TransformNode>;
 template class PropertyTree<ClipNode>;
 template class PropertyTree<OpacityNode>;
 
 TransformNodeData::TransformNodeData()
     : target_id(-1),
       content_target_id(-1),
+      source_node_id(-1),
       needs_local_transform_update(true),
       is_invertible(true),
       ancestors_are_invertible(true),
       is_animated(false),
       to_screen_is_animated(false),
       flattens_inherited_transform(false),
       node_and_ancestors_are_flat(true),
       scrolls(false),
       needs_sublayer_scale(false),
       layer_scale_factor(1.0f) {
 }
 
 TransformNodeData::~TransformNodeData() {
 }
 
 void TransformNodeData::update_pre_local_transform(
     const gfx::Point3F& transform_origin) {
   pre_local.MakeIdentity();
   pre_local.Translate3d(-transform_origin.x(), -transform_origin.y(),
                         -transform_origin.z());
 }
 
 void TransformNodeData::update_post_local_transform(
     const gfx::PointF& position,
     const gfx::Point3F& transform_origin) {
   post_local.MakeIdentity();
   post_local.Scale(post_local_scale_factor, post_local_scale_factor);
   post_local.Translate3d(
-      position.x() + parent_offset.x() + transform_origin.x(),
-      position.y() + parent_offset.y() + transform_origin.y(),
+      position.x() + source_offset.x() + transform_origin.x(),
+      position.y() + source_offset.y() + transform_origin.y(),
       transform_origin.z());
 }
 
 ClipNodeData::ClipNodeData() : transform_id(-1), target_id(-1) {
 }
 
 bool TransformTree::ComputeTransform(int source_id,
                                      int dest_id,
                                      gfx::Transform* transform) const {
   transform->MakeIdentity();
@@ skipping 43 matching lines @@
 bool TransformTree::Are2DAxisAligned(int source_id, int dest_id) const {
   gfx::Transform transform;
   return ComputeTransform(source_id, dest_id, &transform) &&
          transform.Preserves2dAxisAlignment();
 }
 
 void TransformTree::UpdateTransforms(int id) {
   TransformNode* node = Node(id);
   TransformNode* parent_node = parent(node);
   TransformNode* target_node = Node(node->data.target_id);
-  if (node->data.needs_local_transform_update)
+  if (node->data.needs_local_transform_update ||
+      node->parent_id != node->data.source_node_id)
     UpdateLocalTransform(node);
   UpdateScreenSpaceTransform(node, parent_node, target_node);
   UpdateSublayerScale(node);
   UpdateTargetSpaceTransform(node, target_node);
   UpdateIsAnimated(node, parent_node);
   UpdateSnapping(node);
 }
 
 bool TransformTree::IsDescendant(int desc_id, int source_id) const {
   while (desc_id != source_id) {
@@ skipping 87 matching lines @@
   gfx::Transform dest_to_source;
   CombineTransformsBetween(dest_id, source_id, &dest_to_source);
   gfx::Transform source_to_dest;
   bool all_are_invertible = dest_to_source.GetInverse(&source_to_dest);
   transform->PreconcatTransform(source_to_dest);
   return all_are_invertible;
 }
 
 void TransformTree::UpdateLocalTransform(TransformNode* node) {
   gfx::Transform transform = node->data.post_local;
-  transform.Translate(-node->data.scroll_offset.x(),
-                      -node->data.scroll_offset.y());
+  gfx::Vector2dF source_to_parent;
+  if (node->parent_id != node->data.source_node_id) {
+    gfx::Transform to_parent;
+    ComputeTransform(node->data.source_node_id, node->parent_id, &to_parent);
+    source_to_parent = to_parent.To2dTranslation();
+  }
+  transform.Translate(source_to_parent.x() - node->data.scroll_offset.x(),
+                      source_to_parent.y() - node->data.scroll_offset.y());
   transform.PreconcatTransform(node->data.local);
   transform.PreconcatTransform(node->data.pre_local);
   node->data.set_to_parent(transform);
   node->data.needs_local_transform_update = false;
 }
 
 void TransformTree::UpdateScreenSpaceTransform(TransformNode* node,
                                                TransformNode* parent_node,
                                                TransformNode* target_node) {
   if (!parent_node) {
@@ skipping 85 matching lines @@
   node->data.from_screen.matrix().postTranslate(-translation.x(),
                                                 -translation.y(), 0);
 
   node->data.scroll_snap = translation;
 }
 
 PropertyTrees::PropertyTrees() : needs_rebuild(true) {
 }
 
 }  // namespace cc