cc: Put to_target and to_screen behind an accessor.

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 <stddef.h>
 
 #include <memory>
@@ skipping 13 matching lines @@
 }
 
 namespace cc {
 
 namespace proto {
 class ClipNodeData;
 class EffectNodeData;
 class PropertyTree;
 class PropertyTrees;
 class ScrollNodeData;
-class TranformNodeData;
+class TransformNodeData;
+class TransformCachedNodeData;
 class TransformTreeData;
 class TreeNode;
 }
 
 class CopyOutputRequest;
 class LayerTreeImpl;
 class RenderSurfaceImpl;
 class ScrollState;
 struct ScrollAndScaleSet;
 
@@ skipping 42 matching lines @@
   // directly on the transform/scroll display list items when that's possible,
   // or potentially in a scroll tree.
   //
   // TODO(vollick): will be moved when accelerated effects are implemented.
   gfx::Transform pre_local;
   gfx::Transform local;
   gfx::Transform post_local;
 
   gfx::Transform to_parent;
 
-  gfx::Transform to_target;
-  gfx::Transform from_target;
-
-  gfx::Transform to_screen;
-  gfx::Transform from_screen;
-
-  int target_id;
-  // This id is used for all content that draws into a render surface associated
-  // with this transform node.
-  int content_target_id;
-
   // This is the node with respect to which source_offset is defined. This will
   // not be needed once layerization moves to cc, but is needed in order to
   // efficiently update the transform tree for changes to position in the layer
   // tree.
   int source_node_id;
 
   // This id determines which 3d rendering context the node is in. 0 is a
   // special value and indicates that the node is not in any 3d rendering
   // context.
   int sorting_context_id;
@@ skipping 88 matching lines @@
 
   void update_post_local_transform(const gfx::PointF& position,
                                    const gfx::Point3F& transform_origin);
 
   void ToProtobuf(proto::TreeNode* proto) const;
   void FromProtobuf(const proto::TreeNode& proto);
 
   void AsValueInto(base::trace_event::TracedValue* value) const;
 };
 
+struct CC_EXPORT TransformCachedNodeData {
+  TransformCachedNodeData();
+  TransformCachedNodeData(const TransformCachedNodeData& other);
+  ~TransformCachedNodeData();
+
+  gfx::Transform from_target;
+  gfx::Transform to_target;
+  gfx::Transform from_screen;
+  gfx::Transform to_screen;
+  int target_id;
+  // This id is used for all content that draws into a render surface associated
+  // with this transform node.
+  int content_target_id;
+
+  bool operator==(const TransformCachedNodeData& other) const;
+
+  void ToProtobuf(proto::TransformCachedNodeData* proto) const;
+  void FromProtobuf(const proto::TransformCachedNodeData& proto);
+};
+
 typedef TreeNode<TransformNodeData> TransformNode;
 
 struct CC_EXPORT ClipNodeData {
   ClipNodeData();
   ClipNodeData(const ClipNodeData& other);
 
   // The clip rect that this node contributes, expressed in the space of its
   // transform node.
   gfx::RectF clip;
 
@@ skipping 173 matching lines @@
   PropertyTrees* property_trees_;
 };
 
 class CC_EXPORT TransformTree final : public PropertyTree<TransformNode> {
  public:
   TransformTree();
   ~TransformTree();
 
   bool operator==(const TransformTree& other) const;
 
+  int Insert(const TransformNode& tree_node, int parent_id);
+
   void clear();
 
   // Computes the change of basis transform from node |source_id| to |dest_id|.
   // The function returns false iff the inverse of a singular transform was
   // used (and the result should, therefore, not be trusted). Transforms may
   // be computed between any pair of nodes that have an ancestor/descendant
   // relationship. Transforms between other pairs of nodes may only be computed
   // if the following condition holds: let id1 the larger id and let id2 be the
   // other id; then the nearest ancestor of node id1 whose id is smaller than
   // id2 is the lowest common ancestor of the pair of nodes, and the transform
@@ skipping 79 matching lines @@
 
   const std::vector<int>& nodes_affected_by_inner_viewport_bounds_delta()
       const {
     return nodes_affected_by_inner_viewport_bounds_delta_;
   }
   const std::vector<int>& nodes_affected_by_outer_viewport_bounds_delta()
       const {
     return nodes_affected_by_outer_viewport_bounds_delta_;
   }
 
+  const gfx::Transform& FromTarget(int node_id) const;
+  void SetFromTarget(int node_id, const gfx::Transform& transform);
+
+  const gfx::Transform& ToTarget(int node_id) const;
+  void SetToTarget(int node_id, const gfx::Transform& transform);
+
+  const gfx::Transform& FromScreen(int node_id) const;
+  void SetFromScreen(int node_id, const gfx::Transform& transform);
+
+  const gfx::Transform& ToScreen(int node_id) const;
+  void SetToScreen(int node_id, const gfx::Transform& transform);
+
+  int TargetId(int node_id) const;
+  void SetTargetId(int node_id, int target_id);
+
+  int ContentTargetId(int node_id) const;
+  void SetContentTargetId(int node_id, int content_target_id);
+
+  const std::vector<TransformCachedNodeData>& cached_data() const {
+    return cached_data_;
+  }
+
   gfx::Transform ToScreenSpaceTransformWithoutSublayerScale(int id) const;
 
   void ToProtobuf(proto::PropertyTree* proto) const;
   void FromProtobuf(const proto::PropertyTree& proto,
                     std::unordered_map<int, int>* node_id_to_index_map);
 
  private:
   // Returns true iff the node at |desc_id| is a descendant of the node at
   // |anc_id|.
   bool IsDescendant(int desc_id, int anc_id) const;
@@ skipping 30 matching lines @@
 
   bool source_to_parent_updates_allowed_;
   // When to_screen transform has perspective, the transform node's sublayer
   // scale is calculated using page scale factor, device scale factor and the
   // scale factor of device transform. So we need to store them explicitly.
   float page_scale_factor_;
   float device_scale_factor_;
   float device_transform_scale_factor_;
   std::vector<int> nodes_affected_by_inner_viewport_bounds_delta_;
   std::vector<int> nodes_affected_by_outer_viewport_bounds_delta_;
+  std::vector<TransformCachedNodeData> cached_data_;
 };
 
 class CC_EXPORT ClipTree final : public PropertyTree<ClipNode> {
  public:
   bool operator==(const ClipTree& other) const;
 
   void SetViewportClip(gfx::RectF viewport_rect);
   gfx::RectF ViewportClip();
 
   void ToProtobuf(proto::PropertyTree* proto) const;
@@ skipping 171 matching lines @@
 
  private:
   gfx::Vector2dF inner_viewport_container_bounds_delta_;
   gfx::Vector2dF outer_viewport_container_bounds_delta_;
   gfx::Vector2dF inner_viewport_scroll_bounds_delta_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_PROPERTY_TREE_H_