Reuse property trees

cc/trees/property_tree.h

 // 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.
 
 #ifndef CC_TREES_PROPERTY_TREE_H_
 #define CC_TREES_PROPERTY_TREE_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "cc/base/cc_export.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
 template <typename T>
 struct CC_EXPORT TreeNode {
-  TreeNode() : id(-1), parent_id(-1), data() {}
+  TreeNode() : id(-1), parent_id(-1), owner_id(-1), data() {}
   int id;
   int parent_id;
+  int owner_id;
   T data;
 };
 
 struct CC_EXPORT TransformNodeData {
   TransformNodeData();
   ~TransformNodeData();
 
   // The local transform information is combined to form to_parent (ignoring
   // snapping) as follows:
   //
@@ skipping 43 matching lines @@
   // This is true if the to_parent transform at every node on the path to the
   // root is flat.
   bool node_and_ancestors_are_flat;
 
   bool scrolls;
 
   bool needs_sublayer_scale;
   // This is used as a fallback when we either cannot adjust raster scale or if
   // the raster scale cannot be extracted from the screen space transform.
   float layer_scale_factor;
+
+  // TODO(vollick): will be moved when accelerated effects are implemented.
+  float post_local_scale_factor;
+
   gfx::Vector2dF sublayer_scale;
 
   // TODO(vollick): will be moved when accelerated effects are implemented.
   gfx::Vector2dF scroll_offset;
 
   // We scroll snap where possible, but this has an effect on scroll
   // compensation: the snap is yet more scrolling that must be compensated for.
   // This value stores the snapped amount for this purpose.
   gfx::Vector2dF scroll_snap;
 
+  // TODO(vollick): will be moved when accelerated effects are implemented.
+  gfx::Vector2dF parent_offset;
+
   void set_to_parent(const gfx::Transform& transform) {
     to_parent = transform;
     is_invertible = to_parent.IsInvertible();
   }
+
+  void update_post_local_transform(const gfx::PointF& position,
+                                   const gfx::Point3F& transform_origin);
 };
 
 typedef TreeNode<TransformNodeData> TransformNode;
 
 struct CC_EXPORT ClipNodeData {
   ClipNodeData();
 
   gfx::RectF clip;
   gfx::RectF combined_clip;
   int transform_id;
   int target_id;
 };
 
 typedef TreeNode<ClipNodeData> ClipNode;
 
 typedef TreeNode<float> OpacityNode;
 
 template <typename T>
 class CC_EXPORT PropertyTree {
  public:
   PropertyTree();
   virtual ~PropertyTree();
 
   int Insert(const T& tree_node, int parent_id);
 
-  T* Node(int i) { return i > -1 ? &nodes_[i] : nullptr; }
-  const T* Node(int i) const { return i > -1 ? &nodes_[i] : nullptr; }
+  T* Node(int i) {
+    return i > -1 && i < static_cast<int>(size()) ? &nodes_[i] : nullptr;

[ajuma, 2015/04/16 14:52:14]

Do we need this check because we're winding up with stale ids somewhere? Or
could this be a DCHECK?

[Ian Vollick, 2015/04/17 14:56:22]

This was due to a bad bug! What was happening was that in the unit tests, we'd
get fresh (i.e. empty) property trees each time we ran CDP because each
CalcDrawPropertiesInputsForTesting would have a new batch. I've updated the unit
tests to reuse the LTH's property trees where applicable (and removed this
unnecessary stuff).

+  }
+  const T* Node(int i) const {
+    return i > -1 && i < static_cast<int>(size()) ? &nodes_[i] : nullptr;
+  }
 
-  T* parent(const T* t) {
-    return t->parent_id > -1 ? Node(t->parent_id) : nullptr;
-  }
-  const T* parent(const T* t) const {
-    return t->parent_id > -1 ? Node(t->parent_id) : nullptr;
-  }
+  T* parent(const T* t) { return Node(t->parent_id); }
+  const T* parent(const T* t) const { return Node(t->parent_id); }
 
   T* back() { return size() ? &nodes_[nodes_.size() - 1] : nullptr; }
   const T* back() const {
     return size() ? &nodes_[nodes_.size() - 1] : nullptr;
   }
 
-  void clear() { nodes_.clear(); }
+  void clear();
   size_t size() const { return nodes_.size(); }
 
  private:
   // Copy and assign are permitted. This is how we do tree sync.
   std::vector<T> nodes_;
 };
 
 class CC_EXPORT TransformTree final : public PropertyTree<TransformNode> {
  public:
   // Computes the change of basis transform from node |source_id| to |dest_id|.
@@ skipping 56 matching lines @@
   void UpdateIsAnimated(TransformNode* node, TransformNode* parent_node);
   void UpdateSnapping(TransformNode* node);
 };
 
 class CC_EXPORT ClipTree final : public PropertyTree<ClipNode> {};
 
 class CC_EXPORT OpacityTree final : public PropertyTree<OpacityNode> {};
 
 class CC_EXPORT PropertyTrees final {
  public:
+  PropertyTrees();
+
   TransformTree transform_tree;
   OpacityTree opacity_tree;
   ClipTree clip_tree;
+  bool needs_rebuild;
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_PROPERTY_TREE_H_