cc: Make impl-thread property trees handle fixed-position layers

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"
 
 namespace cc {
 
 template <typename T>
 PropertyTree<T>::PropertyTree()
     : needs_update_(false) {
   nodes_.push_back(T());
   back()->id = 0;
   back()->parent_id = -1;
 }
 
 template <typename T>
 PropertyTree<T>::~PropertyTree() {
 }
 
+TransformTree::TransformTree() : source_to_parent_updates_allowed_(true) {
+}
+
 template <typename T>
 int PropertyTree<T>::Insert(const T& tree_node, int parent_id) {
   DCHECK_GT(nodes_.size(), 0u);
   nodes_.push_back(tree_node);
   T& node = nodes_.back();
   node.parent_id = parent_id;
   node.id = static_cast<int>(nodes_.size()) - 1;
   return node.id;
 }
 
@@ skipping 94 matching lines @@
                    1.f / source_node->data.sublayer_scale.y());
   return success;
 }
 
 bool TransformTree::Are2DAxisAligned(int source_id, int dest_id) const {
   gfx::Transform transform;
   return ComputeTransform(source_id, dest_id, &transform) &&
          transform.Preserves2dAxisAlignment();
 }
 
+bool TransformTree::NeedsSourceToParentUpdate(TransformNode* node) {
+  return (source_to_parent_updates_allowed() &&
+          node->parent_id != node->data.source_node_id);
+}
+
 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 ||
-      node->parent_id != node->data.source_node_id)
+      NeedsSourceToParentUpdate(node))
     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 111 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;
-  gfx::Vector2dF source_to_parent;
-  if (node->parent_id != node->data.source_node_id) {
+  if (NeedsSourceToParentUpdate(node)) {
     gfx::Transform to_parent;
     ComputeTransform(node->data.source_node_id, node->parent_id, &to_parent);
-    source_to_parent = to_parent.To2dTranslation();
+    node->data.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.Translate(
+      node->data.source_to_parent.x() - node->data.scroll_offset.x(),
+      node->data.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), sequence_number(0) {
 }
 
 }  // namespace cc