cc: Fix property tree position updates when rebuilding is skipped

cc/trees/property_tree_builder.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/property_tree_builder.h"
 
 #include <map>
 #include <set>
 
 #include "cc/base/math_util.h"
@@ skipping 167 matching lines @@
           Animation::TRANSFORM);
 
   const bool has_surface = !!layer->render_surface();
 
   bool requires_node = is_root || is_scrollable || has_significant_transform ||
                        has_potentially_animated_transform || has_surface ||
                        is_page_scale_application_layer;
 
   LayerType* transform_parent = GetTransformParent(data_from_ancestor, layer);
 
-  gfx::Vector2dF parent_offset;
+  int parent_index = 0;
+  if (transform_parent)
+    parent_index = transform_parent->transform_tree_index();
+
+  int source_index = parent_index;
+
+  gfx::Vector2dF source_offset;
   if (transform_parent) {
     if (layer->scroll_parent()) {
-      gfx::Transform to_parent;
       LayerType* source = layer->parent();
-      parent_offset += source->offset_to_transform_parent();
-      data_from_ancestor.transform_tree->ComputeTransform(
-          source->transform_tree_index(),
-          transform_parent->transform_tree_index(), &to_parent);
-      parent_offset += to_parent.To2dTranslation();
+      source_offset += source->offset_to_transform_parent();
+      source_index = source->transform_tree_index();
     } else if (!is_fixed) {
-      parent_offset = transform_parent->offset_to_transform_parent();
+      source_offset = transform_parent->offset_to_transform_parent();
     } else {
       if (data_from_ancestor.transform_tree_parent !=
           data_from_ancestor.transform_fixed_parent) {
-        gfx::Vector2dF fixed_offset = data_from_ancestor.transform_tree_parent
-                                          ->offset_to_transform_parent();
-        gfx::Transform parent_to_parent;
-        data_from_ancestor.transform_tree->ComputeTransform(
-            data_from_ancestor.transform_tree_parent->transform_tree_index(),
-            data_from_ancestor.transform_fixed_parent->transform_tree_index(),
-            &parent_to_parent);
-
-        fixed_offset += parent_to_parent.To2dTranslation();
-        parent_offset += fixed_offset;
+        source_offset = data_from_ancestor.transform_tree_parent
+                            ->offset_to_transform_parent();
+        source_index =
+            data_from_ancestor.transform_tree_parent->transform_tree_index();
       }
-      parent_offset += data_from_ancestor.scroll_compensation_adjustment;
+      source_offset += data_from_ancestor.scroll_compensation_adjustment;
     }
   }
 
   if (layer->IsContainerForFixedPositionLayers() || is_root)
     data_for_children->transform_fixed_parent = layer;
   data_for_children->transform_tree_parent = layer;
 
   if (layer->IsContainerForFixedPositionLayers() || is_fixed)
     data_for_children->scroll_compensation_adjustment = gfx::Vector2dF();
 
   if (!requires_node) {
     data_for_children->should_flatten |= layer->should_flatten_transform();
     gfx::Vector2dF local_offset = layer->position().OffsetFromOrigin() +
                                   layer->transform().To2dTranslation();
-    layer->set_offset_to_transform_parent(parent_offset + local_offset);
+    gfx::Vector2dF source_to_parent;
+    if (source_index != parent_index) {
+      gfx::Transform to_parent;
+      data_from_ancestor.transform_tree->ComputeTransform(
+          source_index, parent_index, &to_parent);
+      source_to_parent = to_parent.To2dTranslation();
+    }
+    layer->set_offset_to_transform_parent(source_offset + source_to_parent +
+                                          local_offset);
     layer->set_should_flatten_transform_from_property_tree(
         data_from_ancestor.should_flatten);
-    layer->set_transform_tree_index(transform_parent->transform_tree_index());
+    layer->set_transform_tree_index(parent_index);
     return false;
   }
 
-  int parent_index = 0;
-  if (transform_parent)
-    parent_index = transform_parent->transform_tree_index();
-
   data_for_children->transform_tree->Insert(TransformNode(), parent_index);
 
   TransformNode* node = data_for_children->transform_tree->back();
   layer->set_transform_tree_index(node->id);
 
   node->data.scrolls = is_scrollable;
   node->data.flattens_inherited_transform = data_for_children->should_flatten;
 
   // Surfaces inherently flatten transforms.
   data_for_children->should_flatten =
@@ skipping 19 matching lines @@
     node->data.layer_scale_factor = data_from_ancestor.device_scale_factor;
     if (data_from_ancestor.in_subtree_of_page_scale_application_layer)
       node->data.layer_scale_factor *= data_from_ancestor.page_scale_factor;
   }
 
   if (is_root) {
     node->data.post_local.Scale(post_local_scale_factor,
                                 post_local_scale_factor);
   } else {
     node->data.post_local_scale_factor = post_local_scale_factor;
-    node->data.parent_offset = parent_offset;
+    node->data.source_offset = source_offset;
+    node->data.source_node_id = source_index;
     node->data.update_post_local_transform(layer->position(),
                                            layer->transform_origin());
   }
 
   if (!layer->scroll_parent()) {
     node->data.scroll_offset =
         gfx::ScrollOffsetToVector2dF(layer->CurrentScrollOffset());
   }
 
   node->data.local = layer->transform();
@@ skipping 154 matching lines @@
     float device_scale_factor,
     const gfx::Rect& viewport,
     const gfx::Transform& device_transform,
     PropertyTrees* property_trees) {
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, page_scale_factor, device_scale_factor,
       viewport, device_transform, property_trees);
 }
 
 }  // namespace cc