cc: Put to_target and to_screen behind an accessor.

cc/trees/property_tree.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 <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 753 matching lines @@
 void TransformTree::ResetChangeTracking() {
   for (int id = 1; id < static_cast<int>(size()); ++id) {
     TransformNode* node = Node(id);
     node->data.transform_changed = false;
   }
 }
 
 void TransformTree::UpdateTransforms(int id) {
   TransformNode* node = Node(id);
   TransformNode* parent_node = parent(node);
-  TransformNode* target_node = Node(node->data.target_id);
+  TransformNode* target_node = Node(TargetId(id));
   TransformNode* source_node = Node(node->data.source_node_id);
   if (node->data.needs_local_transform_update ||
       NeedsSourceToParentUpdate(node))
     UpdateLocalTransform(node);
   else
     UndoSnapping(node);
   UpdateScreenSpaceTransform(node, parent_node, target_node);
   UpdateSublayerScale(node);
   UpdateTargetSpaceTransform(node, target_node);
   UpdateAnimationProperties(node, parent_node);
@@ skipping 23 matching lines @@
   // non-trivial flattening between the source and destination nodes. For
   // example, consider the tree R->A->B->C, where B flattens its inherited
   // transform, and A has a non-flat transform. Suppose C is the source and A is
   // the destination. The expected result is C * B. But C's to_screen
   // transform is C * B * flattened(A * R), and A's from_screen transform is
   // R^{-1} * A^{-1}. If at least one of A and R isn't flat, the inverse of
   // flattened(A * R) won't be R^{-1} * A{-1}, so multiplying C's to_screen and
   // A's from_screen will not produce the correct result.
   if (!dest || (dest->data.ancestors_are_invertible &&
                 dest->data.node_and_ancestors_are_flat)) {
-    transform->ConcatTransform(current->data.to_screen);
+    transform->ConcatTransform(ToScreen(current->id));
     if (dest)
       transform->ConcatTransform(dest->data.from_screen);
     return true;
   }
 
   // Flattening is defined in a way that requires it to be applied while
   // traversing downward in the tree. We first identify nodes that are on the
   // path from the source to the destination (this is traversing upward), and
   // then we visit these nodes in reverse order, flattening as needed. We
   // early-out if we get to a node whose target node is the destination, since
   // we can then re-use the target space transform stored at that node. However,
   // we cannot re-use a stored target space transform if the destination has a
   // zero sublayer scale, since stored target space transforms have sublayer
   // scale baked in, but we need to compute an unscaled transform.
   std::vector<int> source_to_destination;
   source_to_destination.push_back(current->id);
   current = parent(current);
   bool destination_has_non_zero_sublayer_scale =
       dest->data.sublayer_scale.x() != 0.f &&
       dest->data.sublayer_scale.y() != 0.f;
   DCHECK(destination_has_non_zero_sublayer_scale ||
          !dest->data.ancestors_are_invertible);
   for (; current && current->id > dest_id; current = parent(current)) {
     if (destination_has_non_zero_sublayer_scale &&
-        current->data.target_id == dest_id &&
-        current->data.content_target_id == dest_id)
+        TargetId(current->id) == dest_id &&
+        ContentTargetId(current->id) == dest_id)
       break;
     source_to_destination.push_back(current->id);
   }
 
   gfx::Transform combined_transform;
   if (current->id > dest_id) {
-    combined_transform = current->data.to_target;
+    combined_transform = ToTarget(current->id);
     // The stored target space transform has sublayer scale baked in, but we
     // need the unscaled transform.
     combined_transform.matrix().postScale(1.0f / dest->data.sublayer_scale.x(),
                                           1.0f / dest->data.sublayer_scale.y(),
                                           1.0f);
   } else if (current->id < dest_id) {
     // We have reached the lowest common ancestor of the source and destination
     // nodes. This case can occur when we are transforming between a node
     // corresponding to a fixed-position layer (or its descendant) and the node
     // corresponding to the layer's render target. For example, consider the
@@ skipping 35 matching lines @@
   DCHECK(source_id < dest_id);
   const TransformNode* current = Node(dest_id);
   const TransformNode* dest = Node(source_id);
   // Just as in CombineTransformsBetween, we can use screen space transforms in
   // this computation only when there isn't any non-trivial flattening
   // involved.
   if (current->data.ancestors_are_invertible &&
       current->data.node_and_ancestors_are_flat) {
     transform->PreconcatTransform(current->data.from_screen);
     if (dest)
-      transform->PreconcatTransform(dest->data.to_screen);
+      transform->PreconcatTransform(ToScreen(dest->id));
     return true;
   }
 
   // Inverting a flattening is not equivalent to flattening an inverse. This
   // means we cannot, for example, use the inverse of each node's to_parent
   // transform, flattening where needed. Instead, we must compute the transform
   // from the destination to the source, with flattening, and then invert the
   // result.
   gfx::Transform dest_to_source;
   CombineTransformsBetween(dest_id, source_id, &dest_to_source);
@@ skipping 34 matching lines @@
   transform.PreconcatTransform(node->data.local);
   transform.PreconcatTransform(node->data.pre_local);
   node->data.set_to_parent(transform);
   node->data.needs_local_transform_update = false;
 }
 
 void TransformTree::UpdateScreenSpaceTransform(TransformNode* node,
                                                TransformNode* parent_node,
                                                TransformNode* target_node) {
   if (!parent_node) {
-    node->data.to_screen = node->data.to_parent;
+    SetToScreen(node->id, node->data.to_parent);
     node->data.ancestors_are_invertible = true;
     node->data.to_screen_is_potentially_animated = false;
     node->data.node_and_ancestors_are_flat = node->data.to_parent.IsFlat();
   } else {
-    node->data.to_screen = parent_node->data.to_screen;
+    gfx::Transform to_screen_space_transform = parent_node->data.to_screen;
     if (node->data.flattens_inherited_transform)
-      node->data.to_screen.FlattenTo2d();
-    node->data.to_screen.PreconcatTransform(node->data.to_parent);
+      to_screen_space_transform.FlattenTo2d();
+    to_screen_space_transform.PreconcatTransform(node->data.to_parent);
     node->data.ancestors_are_invertible =
         parent_node->data.ancestors_are_invertible;
     node->data.node_and_ancestors_are_flat =
         parent_node->data.node_and_ancestors_are_flat &&
         node->data.to_parent.IsFlat();
+    SetToScreen(node->id, to_screen_space_transform);
   }
 
-  if (!node->data.to_screen.GetInverse(&node->data.from_screen))
+  if (!ToScreen(node->id).GetInverse(&node->data.from_screen))
     node->data.ancestors_are_invertible = false;
 }
 
 void TransformTree::UpdateSublayerScale(TransformNode* node) {
   // The sublayer scale depends on the screen space transform, so update it too.
   if (!node->data.needs_sublayer_scale) {
     node->data.sublayer_scale = gfx::Vector2dF(1.0f, 1.0f);
     return;
   }
 
   float layer_scale_factor =
       device_scale_factor_ * device_transform_scale_factor_;
   if (node->data.in_subtree_of_page_scale_layer)
     layer_scale_factor *= page_scale_factor_;
   node->data.sublayer_scale = MathUtil::ComputeTransform2dScaleComponents(
-      node->data.to_screen, layer_scale_factor);
+      ToScreen(node->id), layer_scale_factor);
 }
 
 void TransformTree::UpdateTargetSpaceTransform(TransformNode* node,
                                                TransformNode* target_node) {
+  gfx::Transform target_space_transform;
   if (node->data.needs_sublayer_scale) {
-    node->data.to_target.MakeIdentity();
-    node->data.to_target.Scale(node->data.sublayer_scale.x(),
-                               node->data.sublayer_scale.y());
+    target_space_transform.MakeIdentity();
+    target_space_transform.Scale(node->data.sublayer_scale.x(),
+                                 node->data.sublayer_scale.y());
   } else {
     // In order to include the root transform for the root surface, we walk up
     // to the root of the transform tree in ComputeTransform.
     int target_id = target_node->id;
     ComputeTransformWithDestinationSublayerScale(node->id, target_id,
-                                                 &node->data.to_target);
+                                                 &target_space_transform);
   }
 
-  if (!node->data.to_target.GetInverse(&node->data.from_target))
+  if (!target_space_transform.GetInverse(&node->data.from_target))
     node->data.ancestors_are_invertible = false;
+  SetToTarget(node->id, target_space_transform);
 }
 
 void TransformTree::UpdateAnimationProperties(TransformNode* node,
                                               TransformNode* parent_node) {
   bool ancestor_is_animating = false;
   bool ancestor_is_animating_scale = false;
   float ancestor_maximum_target_scale = 0.f;
   float ancestor_starting_animation_scale = 0.f;
   if (parent_node) {
     ancestor_is_animating = parent_node->data.to_screen_is_potentially_animated;
@@ skipping 11 matching lines @@
       ancestor_is_animating_scale;
 
   // Once we've failed to compute a maximum animated scale at an ancestor, we
   // continue to fail.
   bool failed_at_ancestor =
       ancestor_is_animating_scale && ancestor_maximum_target_scale == 0.f;
 
   // Computing maximum animated scale in the presence of non-scale/translation
   // transforms isn't supported.
   bool failed_for_non_scale_or_translation =
-      !node->data.to_target.IsScaleOrTranslation();
+      !ToTarget(node->id).IsScaleOrTranslation();
 
   // We don't attempt to accumulate animation scale from multiple nodes with
   // scale animations, because of the risk of significant overestimation. For
   // example, one node might be increasing scale from 1 to 10 at the same time
   // as another node is decreasing scale from 10 to 1. Naively combining these
   // scales would produce a scale of 100.
   bool failed_for_multiple_scale_animations =
       ancestor_is_animating_scale &&
       !node->data.has_only_translation_animations;
 
@@ skipping 30 matching lines @@
 
   if (node->data.local_starting_animation_scale == 0.f ||
       node->data.local_maximum_animation_target_scale == 0.f) {
     node->data.combined_maximum_animation_target_scale = 0.f;
     node->data.combined_starting_animation_scale = 0.f;
     return;
   }
 
   gfx::Vector2dF ancestor_scales =
       parent_node ? MathUtil::ComputeTransform2dScaleComponents(
-                        parent_node->data.to_target, 0.f)
+                        ToTarget(parent_node->id), 0.f)
                   : gfx::Vector2dF(1.f, 1.f);
   float max_ancestor_scale = std::max(ancestor_scales.x(), ancestor_scales.y());
   node->data.combined_maximum_animation_target_scale =
       max_ancestor_scale * node->data.local_maximum_animation_target_scale;
   node->data.combined_starting_animation_scale =
       max_ancestor_scale * node->data.local_starting_animation_scale;
 }
 
 void TransformTree::UndoSnapping(TransformNode* node) {
   // to_parent transform has the scroll snap from previous frame baked in.
   // We need to undo it and use the un-snapped transform to compute current
   // target and screen space transforms.
   node->data.to_parent.Translate(-node->data.scroll_snap.x(),
                                  -node->data.scroll_snap.y());
 }
 
 void TransformTree::UpdateSnapping(TransformNode* node) {
   if (!node->data.scrolls || node->data.to_screen_is_potentially_animated ||
-      !node->data.to_screen.IsScaleOrTranslation() ||
+      !ToScreen(node->id).IsScaleOrTranslation() ||
       !node->data.ancestors_are_invertible) {
     return;
   }
 
   // Scroll snapping must be done in screen space (the pixels we care about).
   // This means we effectively snap the screen space transform. If ST is the
   // screen space transform and ST' is ST with its translation components
   // rounded, then what we're after is the scroll delta X, where ST * X = ST'.
   // I.e., we want a transform that will realize our scroll snap. It follows
   // that X = ST^-1 * ST'. We cache ST and ST^-1 to make this more efficient.
-  gfx::Transform rounded = node->data.to_screen;
+  gfx::Transform rounded = ToScreen(node->id);
   rounded.RoundTranslationComponents();
   gfx::Transform delta = node->data.from_screen;
   delta *= rounded;
 
   DCHECK(delta.IsApproximatelyIdentityOrTranslation(SkDoubleToMScalar(1e-4)))
       << delta.ToString();
 
   gfx::Vector2dF translation = delta.To2dTranslation();
 
   // Now that we have our scroll delta, we must apply it to each of our
   // combined, to/from matrices.
-  node->data.to_screen = rounded;
+  SetToScreen(node->id, rounded);
   node->data.to_parent.Translate(translation.x(), translation.y());
   node->data.from_screen.matrix().postTranslate(-translation.x(),
                                                 -translation.y(), 0);
-  node->data.to_target.Translate(translation.x(), translation.y());
+  gfx::Transform to_target = ToTarget(node->id);
+  to_target.Translate(translation.x(), translation.y());
+  SetToTarget(node->id, to_target);
   node->data.from_target.matrix().postTranslate(-translation.x(),
                                                 -translation.y(), 0);
 
   node->data.scroll_snap = translation;
 }
 
 void TransformTree::UpdateTransformChanged(TransformNode* node,
                                            TransformNode* parent_node,
                                            TransformNode* source_node) {
   if (parent_node && parent_node->data.transform_changed) {
@@ skipping 82 matching lines @@
 }
 
 bool TransformTree::HasNodesAffectedByInnerViewportBoundsDelta() const {
   return !nodes_affected_by_inner_viewport_bounds_delta_.empty();
 }
 
 bool TransformTree::HasNodesAffectedByOuterViewportBoundsDelta() const {
   return !nodes_affected_by_outer_viewport_bounds_delta_.empty();
 }
 
+gfx::Transform TransformTree::ToTarget(int id) const {
+  return Node(id)->data.to_target;
+}
+
+void TransformTree::SetToTarget(int id, const gfx::Transform& transform) {
+  Node(id)->data.to_target = transform;
+}
+
+gfx::Transform TransformTree::ToScreen(int id) const {
+  return Node(id)->data.to_screen;
+}
+
+void TransformTree::SetToScreen(int id, const gfx::Transform& transform) {
+  Node(id)->data.to_screen = transform;
+}
+
+int TransformTree::TargetId(int id) const {
+  return Node(id)->data.target_id;
+}
+
+void TransformTree::SetTargetId(int id, int target_id) {
+  Node(id)->data.target_id = target_id;
+}
+
+int TransformTree::ContentTargetId(int id) const {
+  return Node(id)->data.content_target_id;
+}
+
+void TransformTree::SetContentTargetId(int id, int content_target_id) {
+  Node(id)->data.content_target_id = content_target_id;
+}
+
 gfx::Transform TransformTree::ToScreenSpaceTransformWithoutSublayerScale(
     int id) const {
   DCHECK_GT(id, 0);
   if (id == 1) {
     return gfx::Transform();
   }
   const TransformNode* node = Node(id);
-  gfx::Transform screen_space_transform = node->data.to_screen;
+  gfx::Transform screen_space_transform = ToScreen(id);
   if (node->data.sublayer_scale.x() != 0.0 &&
       node->data.sublayer_scale.y() != 0.0)
     screen_space_transform.Scale(1.0 / node->data.sublayer_scale.x(),
                                  1.0 / node->data.sublayer_scale.y());
   return screen_space_transform;
 }
 
 bool TransformTree::operator==(const TransformTree& other) const {
   return PropertyTree::operator==(other) &&
          source_to_parent_updates_allowed_ ==
@@ skipping 116 matching lines @@
         transform_tree.Node(node->data.transform_id);
     if (transform_node->data.is_invertible &&
         transform_node->data.ancestors_are_invertible) {
       if (transform_node->data.sorting_context_id) {
         const TransformNode* parent_transform_node =
             transform_tree.parent(transform_node);
         if (parent_transform_node &&
             parent_transform_node->data.sorting_context_id ==
                 transform_node->data.sorting_context_id) {
           gfx::Transform surface_draw_transform;
-          transform_tree.ComputeTransform(transform_node->id,
-                                          transform_node->data.target_id,
-                                          &surface_draw_transform);
+          transform_tree.ComputeTransform(
+              transform_node->id, transform_tree.TargetId(transform_node->id),
+              &surface_draw_transform);
           node->data.hidden_by_backface_visibility =
               surface_draw_transform.IsBackFaceVisible();
         } else {
           node->data.hidden_by_backface_visibility =
               transform_node->data.local.IsBackFaceVisible();
         }
         return;
       }
     }
   }
@@ skipping 343 matching lines @@
   const ScrollNode* scroll_node = Node(currently_scrolling_node_id_);
   return scroll_node;
 }
 
 void ScrollTree::set_currently_scrolling_node(int scroll_node_id) {
   currently_scrolling_node_id_ = scroll_node_id;
 }
 
 gfx::Transform ScrollTree::ScreenSpaceTransform(int scroll_node_id) const {
   const ScrollNode* scroll_node = Node(scroll_node_id);
+  const TransformTree& transform_tree = property_trees()->transform_tree;
   const TransformNode* transform_node =
-      property_trees()->transform_tree.Node(scroll_node->data.transform_id);
+      transform_tree.Node(scroll_node->data.transform_id);
   gfx::Transform screen_space_transform(
       1, 0, 0, 1, scroll_node->data.offset_to_transform_parent.x(),
       scroll_node->data.offset_to_transform_parent.y());
-  screen_space_transform.ConcatTransform(transform_node->data.to_screen);
+  screen_space_transform.ConcatTransform(
+      transform_tree.ToScreen(transform_node->id));
   if (scroll_node->data.should_flatten)
     screen_space_transform.FlattenTo2d();
   return screen_space_transform;
 }
 
 SyncedScrollOffset* ScrollTree::synced_scroll_offset(int layer_id) {
   if (layer_id_to_scroll_offset_map_.find(layer_id) ==
       layer_id_to_scroll_offset_map_.end()) {
     layer_id_to_scroll_offset_map_[layer_id] = new SyncedScrollOffset;
   }
@@ skipping 458 matching lines @@
   value->EndDictionary();
 
   value->BeginDictionary("scroll_tree");
   scroll_tree.AsValueInto(value.get());
   value->EndDictionary();
 
   return value;
 }
 
 }  // namespace cc