Introduce 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"
@@ skipping 10 matching lines @@
       : id(-1),
         parent_id(-1),
         value(value),
         layer(layer) {}
   int id;
   int parent_id;
   T value;
   Layer* layer;
 };
 
-typedef TreeNode<double> OpacityTreeNode;
+typedef TreeNode<double> OpacityNode;
 
-struct TransformTreeNode : public TreeNode<gfx::Transform> {
-  TransformTreeNode(Layer* layer, const gfx::Transform& transform);
-  ~TransformTreeNode();
+struct TransformNode : public TreeNode<gfx::Transform> {
+  TransformNode(Layer* layer, const gfx::Transform& transform);
+  ~TransformNode();
   // TODO(awoloszyn): can we rework the algorithm so that we don't need this
   // rect?
   gfx::Transform clip_transform_from_transform_parent;
   gfx::RectF clip_rect;
 };
 
-struct ClipTreeNode : public TreeNode<gfx::RectF> {
-  ClipTreeNode(Layer* layer, const gfx::RectF& rect);
-  ClipTreeNode(Layer* layer, const gfx::RectF& rect, bool clips);
+struct ClipNode : public TreeNode<gfx::RectF> {
+  ClipNode(Layer* layer, const gfx::RectF& rect);
+  ClipNode(Layer* layer, const gfx::RectF& rect, bool clips);
   gfx::RectF GetClipForLayer(Layer* layer) const {
     if(clips)
       return value;
     return gfx::RectF(layer->content_bounds());
   }
-  ~ClipTreeNode();
+  ~ClipNode();
 
-  // ClipTreeNodes that don't clip are used to reset clipping state.
+  // ClipNodes that don't clip are used to reset clipping state.
   bool clips;
 };
 
 template <typename T>
 class PropertyTree {
  public:
-  PropertyTree();
+  explicit PropertyTree(Layer* root);
   // Not virtual. Should not derive from this class.
   ~PropertyTree();
 
-  // Returns id of inserted layer.
-  int InsertRootNode(const T& tree_node);
+  // TODO(vollick): we can probably do without the return value.
+  int InsertWithParent(const T& tree_node, int parent_id);
 
-  // Returns id of inserted layer.
-  int InsertWithParent(const T& tree_node, int parent_id);
   int GetLastNodeID() const;
 
   T* Node(int id);
   const T* Node(int id) const;
 
   T* root() { return Node(0); }
   const T* root() const { return Node(0); }
 
   void clear() { nodes_.clear(); }
   typedef T NodeType;
 
  private:
+  int InsertRootNode(const T& tree_node);
   std::vector<T> nodes_;
 };
 
-typedef PropertyTree<TransformTreeNode> TransformTree;
-typedef PropertyTree<OpacityTreeNode> OpacityTree;
-typedef PropertyTree<ClipTreeNode> ClipTree;
+typedef PropertyTree<TransformNode> TransformTree;
+typedef PropertyTree<OpacityNode> OpacityTree;
+typedef PropertyTree<ClipNode> ClipTree;
 
 }  // namespace cc
 
 #endif  // CC_TREES_PROPERTY_TREE_H_