cc: Put to_target and to_screen behind an accessor.

cc/trees/draw_property_utils.cc

Index: cc/trees/draw_property_utils.cc
diff --git a/cc/trees/draw_property_utils.cc b/cc/trees/draw_property_utils.cc
index 0cd7b3c9dfe1df9749383160f4fa8309a60460b2..df4571c6616916f696b804b32901fbd1676a5bb9 100644
--- a/cc/trees/draw_property_utils.cc
+++ b/cc/trees/draw_property_utils.cc
@@ -167,9 +167,10 @@ void CalculateVisibleRects(
       }
 
       // The clip rect should be intersected with layer rect in target space.
-      gfx::Transform content_to_target = non_root_surfaces_enabled
-                                             ? transform_node->data.to_target
-                                             : transform_node->data.to_screen;
+      gfx::Transform content_to_target =
+          non_root_surfaces_enabled
+              ? transform_tree.ToTarget(layer->transform_tree_index())
+              : transform_tree.ToScreen(layer->transform_tree_index());
 
       content_to_target.Translate(layer->offset_to_transform_parent().x(),
                                   layer->offset_to_transform_parent().y());
@@ -252,7 +253,7 @@ static bool IsLayerBackFaceVisible(LayerType* layer,
   const TransformNode* node = tree.Node(transform_tree_index);
   return layer->use_local_transform_for_backface_visibility()
              ? node->data.local.IsBackFaceVisible()
-             : node->data.to_target.IsBackFaceVisible();
+             : tree.ToTarget(transform_tree_index).IsBackFaceVisible();
 }
 
 static inline bool TransformToScreenIsKnown(Layer* layer,
@@ -485,7 +486,8 @@ void ComputeClips(ClipTree* clip_tree,
     if (clip_node->data.resets_clip && non_root_surfaces_enabled) {
       if (clip_node->data.applies_local_clip) {
         clip_node->data.clip_in_target_space = MathUtil::MapClippedRect(
-            transform_node->data.to_target, clip_node->data.clip);
+            transform_tree.ToTarget(clip_node->data.transform_id),
+            clip_node->data.clip);
         ResetIfHasNanCoordinate(&clip_node->data.clip_in_target_space);
         clip_node->data.combined_clip_in_target_space =
             gfx::IntersectRects(clip_node->data.clip_in_target_space,
@@ -518,10 +520,12 @@ void ComputeClips(ClipTree* clip_tree,
       gfx::Transform source_to_target;
 
       if (!non_root_surfaces_enabled) {
-        source_to_target = transform_node->data.to_screen;
+        source_to_target =
+            transform_tree.ToScreen(clip_node->data.transform_id);
       } else if (transform_node->data.content_target_id ==
                  clip_node->data.target_id) {
-        source_to_target = transform_node->data.to_target;
+        source_to_target =
+            transform_tree.ToTarget(clip_node->data.transform_id);
       } else {
         success = transform_tree.ComputeTransformWithDestinationSublayerScale(
             transform_node->id, clip_node->data.target_id, &source_to_target);
@@ -876,7 +880,7 @@ gfx::Transform DrawTransform(const LayerImpl* layer,
   if (!owns_non_root_surface) {
     // If you're not the root, or you don't own a surface, you need to apply
     // your local offset.
-    xform = node->data.to_target;
+    xform = tree.ToTarget(layer->transform_tree_index());
     if (layer->should_flatten_transform_from_property_tree())
       xform.FlattenTo2d();
     xform.Translate(layer->offset_to_transform_parent().x(),
@@ -898,7 +902,7 @@ static void SetSurfaceDrawTransform(const TransformTree& tree,
   }
 
   gfx::Transform render_surface_transform;
-  const TransformNode* target_node = tree.Node(node->data.target_id);
+  const TransformNode* target_node = tree.Node(tree.TargetId(node->id));
   tree.ComputeTransformWithDestinationSublayerScale(node->id, target_node->id,
                                                     &render_surface_transform);
   if (node->data.sublayer_scale.x() != 0.0 &&
@@ -926,7 +930,8 @@ static void SetSurfaceClipRect(const ClipNode* parent_clip_node,
 
   const TransformNode* transform_node =
       transform_tree.Node(render_surface->TransformTreeIndex());
-  if (transform_node->data.target_id == parent_clip_node->data.target_id) {
+  if (transform_tree.TargetId(transform_node->id) ==
+      parent_clip_node->data.target_id) {
     render_surface->SetClipRect(
         gfx::ToEnclosingRect(parent_clip_node->data.clip_in_target_space));
     return;
@@ -938,7 +943,8 @@ static void SetSurfaceClipRect(const ClipNode* parent_clip_node,
   gfx::Transform clip_parent_target_to_target;
   const bool success =
       transform_tree.ComputeTransformWithDestinationSublayerScale(
-          parent_clip_node->data.target_id, transform_node->data.target_id,
+          parent_clip_node->data.target_id,
+          transform_tree.TargetId(transform_node->id),
           &clip_parent_target_to_target);
 
   if (!success) {
@@ -946,7 +952,8 @@ static void SetSurfaceClipRect(const ClipNode* parent_clip_node,
     return;
   }
 
-  DCHECK_LT(parent_clip_node->data.target_id, transform_node->data.target_id);
+  DCHECK_LT(parent_clip_node->data.target_id,
+            transform_tree.TargetId(transform_node->id));
   render_surface->SetClipRect(gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
       clip_parent_target_to_target,
       parent_clip_node->data.clip_in_target_space)));
@@ -954,10 +961,10 @@ static void SetSurfaceClipRect(const ClipNode* parent_clip_node,
 
 template <typename LayerType>
 static gfx::Transform ScreenSpaceTransformInternal(LayerType* layer,
-                                                   const TransformNode* node) {
+                                                   const TransformTree& tree) {
   gfx::Transform xform(1, 0, 0, 1, layer->offset_to_transform_parent().x(),
                        layer->offset_to_transform_parent().y());
-  gfx::Transform ssxform = node->data.to_screen;
+  gfx::Transform ssxform = tree.ToScreen(layer->transform_tree_index());
   xform.ConcatTransform(ssxform);
   if (layer->should_flatten_transform_from_property_tree())
     xform.FlattenTo2d();
@@ -966,14 +973,12 @@ static gfx::Transform ScreenSpaceTransformInternal(LayerType* layer,
 
 gfx::Transform ScreenSpaceTransform(const Layer* layer,
                                     const TransformTree& tree) {
-  return ScreenSpaceTransformInternal(layer,
-                                      tree.Node(layer->transform_tree_index()));
+  return ScreenSpaceTransformInternal(layer, tree);
 }
 
 gfx::Transform ScreenSpaceTransform(const LayerImpl* layer,
                                     const TransformTree& tree) {
-  return ScreenSpaceTransformInternal(layer,
-                                      tree.Node(layer->transform_tree_index()));
+  return ScreenSpaceTransformInternal(layer, tree);
 }
 
 static float LayerDrawOpacity(const LayerImpl* layer, const EffectTree& tree) {
@@ -1081,7 +1086,7 @@ void ComputeLayerDrawProperties(LayerImpl* layer,
       property_trees->clip_tree.Node(layer->clip_tree_index());
 
   layer->draw_properties().screen_space_transform =
-      ScreenSpaceTransformInternal(layer, transform_node);
+      ScreenSpaceTransformInternal(layer, property_trees->transform_tree);
   if (property_trees->non_root_surfaces_enabled) {
     layer->draw_properties().target_space_transform =
         DrawTransform(layer, property_trees->transform_tree);