cc: Put to_target and to_screen behind an accessor.

cc/trees/draw_property_utils.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 "cc/trees/draw_property_utils.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 108 matching lines @@
     }
 
     // When both the layer and the target are unclipped, the entire layer
     // content rect is visible.
     const bool fully_visible = !clip_node->data.layers_are_clipped &&
                                !clip_node->data.target_is_clipped;
 
     if (!fully_visible) {
       const TransformNode* transform_node =
           transform_tree.Node(layer->transform_tree_index());
-      int target_node_id = transform_node->data.content_target_id;
+      int target_node_id = transform_tree.ContentTargetId(transform_node->id);
 
       // The clip node stores clip rect in its target space.
       gfx::RectF clip_rect_in_target_space =
           clip_node->data.clip_in_target_space;
 
       // If required, this clip rect should be mapped to the current layer's
       // target space.
       if (clip_node->data.target_id != target_node_id) {
         // In this case, layer has a clip parent or scroll parent (or shares the
         // target with an ancestor layer that has clip parent) and the clip
@@ skipping 61 matching lines @@
         transform_tree.Node(layer->transform_tree_index());
     if (!non_root_surfaces_enabled) {
       // When we only have a root surface, the clip node and the layer must
       // necessarily have the same target (the root).
       if (transform_node->data.ancestors_are_invertible) {
         gfx::RectF combined_clip_rect_in_target_space =
             clip_node->data.combined_clip_in_target_space;
         gfx::Transform target_to_content;
         target_to_content.Translate(-layer->offset_to_transform_parent().x(),
                                     -layer->offset_to_transform_parent().y());
-        target_to_content.PreconcatTransform(transform_node->data.from_screen);
+        target_to_content.PreconcatTransform(
+            transform_tree.FromScreen(transform_node->id));
 
         gfx::Rect visible_rect =
             gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
                 target_to_content, combined_clip_rect_in_target_space));
         visible_rect.Intersect(gfx::Rect(layer_bounds));
         layer->set_visible_layer_rect(visible_rect);
       } else {
         layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
       }
       continue;
     }
 
     // When both the layer and the target are unclipped, the entire layer
     // content rect is visible.
     const bool fully_visible = !clip_node->data.layers_are_clipped &&
                                !clip_node->data.target_is_clipped;
 
     if (fully_visible) {
       layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
       continue;
     }
 
-    int target_node_id = transform_node->data.content_target_id;
+    int target_node_id = transform_tree.ContentTargetId(transform_node->id);
 
     // The clip node stores clip rect in its target space. If required,
     // this clip rect should be mapped to the current layer's target space.
     gfx::RectF combined_clip_rect_in_target_space;
 
     if (clip_node->data.target_id != target_node_id) {
       // In this case, layer has a clip parent or scroll parent (or shares the
       // target with an ancestor layer that has clip parent) and the clip
       // parent's target is different from the layer's target. As the layer's
       // target has unclippped descendants, it is unclippped.
@@ skipping 17 matching lines @@
       if (clip_node->data.target_is_clipped) {
         combined_clip_rect_in_target_space =
             clip_node->data.combined_clip_in_target_space;
       } else {
         combined_clip_rect_in_target_space =
             clip_node->data.clip_in_target_space;
       }
     }
 
     // The clip rect should be intersected with layer rect in target space.
-    gfx::Transform content_to_target = transform_node->data.to_target;
+    gfx::Transform content_to_target =
+        transform_tree.ToTarget(transform_node->id);
     content_to_target.Translate(layer->offset_to_transform_parent().x(),
                                 layer->offset_to_transform_parent().y());
     gfx::Rect layer_content_rect = gfx::Rect(layer_bounds);
     gfx::RectF layer_content_bounds_in_target_space = MathUtil::MapClippedRect(
         content_to_target, gfx::RectF(layer_content_rect));
     // If the layer is fully contained within the clip, treat it as fully
     // visible.
     if (!layer_content_bounds_in_target_space.IsEmpty() &&
         combined_clip_rect_in_target_space.Contains(
             layer_content_bounds_in_target_space)) {
       layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
       continue;
     }
 
     combined_clip_rect_in_target_space.Intersect(
         layer_content_bounds_in_target_space);
     if (combined_clip_rect_in_target_space.IsEmpty()) {
       layer->set_visible_layer_rect(gfx::Rect());
       continue;
     }
 
     gfx::Transform target_to_layer;
     if (transform_node->data.ancestors_are_invertible) {
-      target_to_layer = transform_node->data.from_target;
+      target_to_layer = transform_tree.FromTarget(transform_node->id);
     } else {
       if (!transform_tree.ComputeTransformWithSourceSublayerScale(
               target_node_id, transform_node->id, &target_to_layer)) {
         // An animated singular transform may become non-singular during the
         // animation, so we still need to compute a visible rect. In this
         // situation, we treat the entire layer as visible.
         layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
         continue;
       }
     }
@@ skipping 25 matching lines @@
   return layer->id() == node->owner_id ? tree.parent(node)->id : node->id;
 }
 
 template <typename LayerType>
 static bool IsLayerBackFaceVisible(LayerType* layer,
                                    int transform_tree_index,
                                    const TransformTree& tree) {
   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,
                                             int transform_tree_index,
                                             const TransformTree& tree) {
   const TransformNode* node = tree.Node(transform_tree_index);
   return !node->data.to_screen_is_potentially_animated;
 }
 
 static inline bool TransformToScreenIsKnown(LayerImpl* layer,
@@ skipping 212 matching lines @@
           parent_to_current, parent_clip_node->data.clip_in_target_space);
     }
     // Only nodes affected by ancestor clips will have their clip adjusted due
     // to intersecting with an ancestor clip. But, we still need to propagate
     // the combined clip to our children because if they are clipped, they may
     // need to clip using our parent clip and if we don't propagate it here,
     // it will be lost.
     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,
                                 parent_combined_clip_in_target_space);
       } else {
         DCHECK(!clip_node->data.target_is_clipped);
         DCHECK(!clip_node->data.layers_are_clipped);
         clip_node->data.combined_clip_in_target_space =
             parent_combined_clip_in_target_space;
       }
@@ skipping 12 matching lines @@
       } else {
         // Render Surface applies clip and the owning layer itself applies
         // no clip. So, clip_in_target_space is not used and hence we can set
         // it to an empty rect.
         clip_node->data.clip_in_target_space = gfx::RectF();
       }
     } else {
       gfx::Transform source_to_target;
 
       if (!non_root_surfaces_enabled) {
-        source_to_target = transform_node->data.to_screen;
-      } else if (transform_node->data.content_target_id ==
+        source_to_target =
+            transform_tree.ToScreen(clip_node->data.transform_id);
+      } else if (transform_tree.ContentTargetId(transform_node->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);
         // source_to_target computation should be successful as target is an
         // ancestor of the transform node.
         DCHECK(success);
       }
 
       gfx::RectF source_clip_in_target_space =
           MathUtil::MapClippedRect(source_to_target, clip_node->data.clip);
@@ skipping 338 matching lines @@
 
 gfx::Transform DrawTransform(const LayerImpl* layer,
                              const TransformTree& tree) {
   const TransformNode* node = tree.Node(layer->transform_tree_index());
   gfx::Transform xform;
   const bool owns_non_root_surface =
       !IsRootLayer(layer) && layer->has_render_surface();
   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(),
                     layer->offset_to_transform_parent().y());
   } else {
     // Surfaces need to apply their sublayer scale.
     xform.Scale(node->data.sublayer_scale.x(), node->data.sublayer_scale.y());
   }
   return xform;
 }
 
 static void SetSurfaceDrawTransform(const TransformTree& tree,
                                     RenderSurfaceImpl* render_surface) {
   const TransformNode* node = tree.Node(render_surface->TransformTreeIndex());
   // The draw transform of root render surface is identity tranform.
   if (node->id == 1) {
     render_surface->SetDrawTransform(gfx::Transform());
     return;
   }
 
   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 &&
       node->data.sublayer_scale.y() != 0.0)
     render_surface_transform.Scale(1.0 / node->data.sublayer_scale.x(),
                                    1.0 / node->data.sublayer_scale.y());
   render_surface->SetDrawTransform(render_surface_transform);
 }
 
 static void SetSurfaceIsClipped(const ClipNode* clip_node,
                                 RenderSurfaceImpl* render_surface) {
   DCHECK(render_surface->OwningLayerId() == clip_node->owner_id)
       << "we now create clip node for every render surface";
 
   render_surface->SetIsClipped(clip_node->data.target_is_clipped);
 }
 
 static void SetSurfaceClipRect(const ClipNode* parent_clip_node,
                                const TransformTree& transform_tree,
                                RenderSurfaceImpl* render_surface) {
   if (!render_surface->is_clipped()) {
     render_surface->SetClipRect(gfx::Rect());
     return;
   }
 
   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;
   }
 
   // In this case, the clip child has reset the clip node for subtree and hence
   // the parent clip node's clip rect is in clip parent's target space and not
   // our target space. We need to transform it to our target space.
   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) {
     render_surface->SetClipRect(gfx::Rect());
     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)));
 }
 
 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();
   return xform;
 }
 
 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) {
   if (!layer->render_target())
     return 0.f;
 
   const EffectNode* target_node =
       tree.Node(layer->render_target()->EffectTreeIndex());
   const EffectNode* node = tree.Node(layer->effect_tree_index());
   if (node == target_node)
@@ skipping 58 matching lines @@
 }
 
 void ComputeLayerDrawProperties(LayerImpl* layer,
                                 const PropertyTrees* property_trees) {
   const TransformNode* transform_node =
       property_trees->transform_tree.Node(layer->transform_tree_index());
   const ClipNode* clip_node =
       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);
   } else {
     layer->draw_properties().target_space_transform =
         layer->draw_properties().screen_space_transform;
   }
   layer->draw_properties().screen_space_transform_is_animating =
       transform_node->data.to_screen_is_potentially_animated;
   if (layer->layer_tree_impl()
@@ skipping 23 matching lines @@
   layer->draw_properties().drawable_content_rect = LayerDrawableContentRect(
       layer, bounds_in_target_space, layer->draw_properties().clip_rect);
 }
 
 void ComputeMaskDrawProperties(LayerImpl* mask_layer,
                                const PropertyTrees* property_trees) {
   // Mask draw properties are used only for rastering, so most of the draw
   // properties computed for other layers are not needed.
   mask_layer->draw_properties().screen_space_transform =
       ScreenSpaceTransformInternal(mask_layer,
-                                   property_trees->transform_tree.Node(
-                                       mask_layer->transform_tree_index()));
+                                   property_trees->transform_tree);
   mask_layer->draw_properties().visible_layer_rect =
       gfx::Rect(mask_layer->bounds());
 }
 
 void ComputeSurfaceDrawProperties(const PropertyTrees* property_trees,
                                   RenderSurfaceImpl* render_surface) {
   const ClipNode* clip_node =
       property_trees->clip_tree.Node(render_surface->ClipTreeIndex());
 
   SetSurfaceIsClipped(clip_node, render_surface);
@@ skipping 115 matching lines @@
 void UpdateElasticOverscroll(PropertyTrees* property_trees,
                              const Layer* overscroll_elasticity_layer,
                              const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer,
                                   elastic_overscroll);
 }
 
 }  // namespace draw_property_utils
 
 }  // namespace cc