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 61 matching lines @@
 }
 
 template <typename T>
 PropertyTree<T>::~PropertyTree() {
 }
 
 TransformTree::TransformTree()
     : source_to_parent_updates_allowed_(true),
       page_scale_factor_(1.f),
       device_scale_factor_(1.f),
-      device_transform_scale_factor_(1.f) {}
+      device_transform_scale_factor_(1.f) {
+  cached_data_.push_back(TransformCachedNodeData());
+}
 
 TransformTree::~TransformTree() {
 }
 
 template <typename T>
 int PropertyTree<T>::Insert(const T& tree_node, int parent_id) {
   DCHECK_GT(nodes_.size(), 0u);
   nodes_.push_back(tree_node);
   T& node = nodes_.back();
   node.parent_id = parent_id;
@@ skipping 55 matching lines @@
   }
   value->EndArray();
 }
 
 template class PropertyTree<TransformNode>;
 template class PropertyTree<ClipNode>;
 template class PropertyTree<EffectNode>;
 template class PropertyTree<ScrollNode>;
 
 TransformNodeData::TransformNodeData()
-    : target_id(-1),
-      content_target_id(-1),
-      source_node_id(-1),
+    : source_node_id(-1),
       sorting_context_id(0),
       needs_local_transform_update(true),
       node_and_ancestors_are_animated_or_invertible(true),
       is_invertible(true),
       ancestors_are_invertible(true),
       has_potential_animation(false),
       is_currently_animating(false),
       to_screen_is_potentially_animated(false),
       has_only_translation_animations(true),
       to_screen_has_scale_animation(false),
@@ skipping 15 matching lines @@
       combined_starting_animation_scale(0.f) {}
 
 TransformNodeData::TransformNodeData(const TransformNodeData& other) = default;
 
 TransformNodeData::~TransformNodeData() {
 }
 
 bool TransformNodeData::operator==(const TransformNodeData& other) const {
   return pre_local == other.pre_local && local == other.local &&
          post_local == other.post_local && to_parent == other.to_parent &&
-         to_target == other.to_target && from_target == other.from_target &&
-         to_screen == other.to_screen && from_screen == other.from_screen &&
-         target_id == other.target_id &&
-         content_target_id == other.content_target_id &&
          source_node_id == other.source_node_id &&
          sorting_context_id == other.sorting_context_id &&
          needs_local_transform_update == other.needs_local_transform_update &&
          node_and_ancestors_are_animated_or_invertible ==
              other.node_and_ancestors_are_animated_or_invertible &&
          is_invertible == other.is_invertible &&
          ancestors_are_invertible == other.ancestors_are_invertible &&
          has_potential_animation == other.has_potential_animation &&
          is_currently_animating == other.is_currently_animating &&
          to_screen_is_potentially_animated ==
@@ skipping 55 matching lines @@
 void TransformNodeData::ToProtobuf(proto::TreeNode* proto) const {
   DCHECK(!proto->has_transform_node_data());
   proto::TranformNodeData* data = proto->mutable_transform_node_data();
 
   TransformToProto(pre_local, data->mutable_pre_local());
   TransformToProto(local, data->mutable_local());
   TransformToProto(post_local, data->mutable_post_local());
 
   TransformToProto(to_parent, data->mutable_to_parent());
 
-  TransformToProto(to_target, data->mutable_to_target());
-  TransformToProto(from_target, data->mutable_from_target());
-
-  TransformToProto(to_screen, data->mutable_to_screen());
-  TransformToProto(from_screen, data->mutable_from_screen());
-
-  data->set_target_id(target_id);
-  data->set_content_target_id(content_target_id);
   data->set_source_node_id(source_node_id);
   data->set_sorting_context_id(sorting_context_id);
 
   data->set_needs_local_transform_update(needs_local_transform_update);
 
   data->set_node_and_ancestors_are_animated_or_invertible(
       node_and_ancestors_are_animated_or_invertible);
 
   data->set_is_invertible(is_invertible);
   data->set_ancestors_are_invertible(ancestors_are_invertible);
@@ skipping 43 matching lines @@
 void TransformNodeData::FromProtobuf(const proto::TreeNode& proto) {
   DCHECK(proto.has_transform_node_data());
   const proto::TranformNodeData& data = proto.transform_node_data();
 
   pre_local = ProtoToTransform(data.pre_local());
   local = ProtoToTransform(data.local());
   post_local = ProtoToTransform(data.post_local());
 
   to_parent = ProtoToTransform(data.to_parent());
 
-  to_target = ProtoToTransform(data.to_target());
-  from_target = ProtoToTransform(data.from_target());
-
-  to_screen = ProtoToTransform(data.to_screen());
-  from_screen = ProtoToTransform(data.from_screen());
-
-  target_id = data.target_id();
-  content_target_id = data.content_target_id();
   source_node_id = data.source_node_id();
   sorting_context_id = data.sorting_context_id();
 
   needs_local_transform_update = data.needs_local_transform_update();
 
   node_and_ancestors_are_animated_or_invertible =
       data.node_and_ancestors_are_animated_or_invertible();
 
   is_invertible = data.is_invertible();
   ancestors_are_invertible = data.ancestors_are_invertible();
@@ skipping 36 matching lines @@
   scroll_snap = ProtoToVector2dF(data.scroll_snap());
   source_offset = ProtoToVector2dF(data.source_offset());
   source_to_parent = ProtoToVector2dF(data.source_to_parent());
 }
 
 void TransformNodeData::AsValueInto(
     base::trace_event::TracedValue* value) const {
   MathUtil::AddToTracedValue("pre_local", pre_local, value);
   MathUtil::AddToTracedValue("local", local, value);
   MathUtil::AddToTracedValue("post_local", post_local, value);
-  value->SetInteger("target_id", target_id);
-  value->SetInteger("content_target_id", content_target_id);
+  // TODO(sunxd): make frameviewer work without target_id
+  value->SetInteger("target_id", 0);
+  value->SetInteger("content_target_id", 0);
   value->SetInteger("source_node_id", source_node_id);
   value->SetInteger("sorting_context_id", sorting_context_id);
 }
 
+TransformCachedNodeData::TransformCachedNodeData()
+    : target_id(-1), content_target_id(-1) {}
+
+TransformCachedNodeData::TransformCachedNodeData(
+    const TransformCachedNodeData& other) = default;
+
+TransformCachedNodeData::~TransformCachedNodeData() {}
+
+bool TransformCachedNodeData::operator==(
+    const TransformCachedNodeData& other) const {
+  return from_target == other.from_target && to_target == other.to_target &&
+         from_screen == other.from_screen && to_screen == other.to_screen &&
+         target_id == other.target_id &&
+         content_target_id == other.content_target_id;
+}
+
+void TransformCachedNodeData::ToProtobuf(
+    proto::TransformCachedNodeData* proto) const {
+  TransformToProto(from_target, proto->mutable_from_target());
+  TransformToProto(to_target, proto->mutable_to_target());
+  TransformToProto(from_screen, proto->mutable_from_screen());
+  TransformToProto(to_screen, proto->mutable_to_screen());
+  proto->set_target_id(target_id);
+  proto->set_content_target_id(content_target_id);
+}
+
+void TransformCachedNodeData::FromProtobuf(
+    const proto::TransformCachedNodeData& proto) {
+  from_target = ProtoToTransform(proto.from_target());
+  to_target = ProtoToTransform(proto.to_target());
+  from_screen = ProtoToTransform(proto.from_screen());
+  to_screen = ProtoToTransform(proto.to_screen());
+  target_id = proto.target_id();
+  content_target_id = proto.content_target_id();
+}
+
 ClipNodeData::ClipNodeData()
     : transform_id(-1),
       target_id(-1),
       applies_local_clip(true),
       layer_clipping_uses_only_local_clip(false),
       target_is_clipped(false),
       layers_are_clipped(false),
       layers_are_clipped_when_surfaces_disabled(false),
       resets_clip(false) {}
 
@@ skipping 261 matching lines @@
   MathUtil::AddToTracedValue("bounds", bounds, value);
   MathUtil::AddToTracedValue("offset_to_transform_parent",
                              offset_to_transform_parent, value);
   value->SetBoolean("should_flatten", should_flatten);
   value->SetBoolean("user_scrollable_horizontal", user_scrollable_horizontal);
   value->SetBoolean("user_scrollable_vertical", user_scrollable_vertical);
   value->SetInteger("element_id", element_id);
   value->SetInteger("transform_id", transform_id);
 }
 
+int TransformTree::Insert(const TransformNode& tree_node, int parent_id) {
+  int node_id = PropertyTree<TransformNode>::Insert(tree_node, parent_id);
+  DCHECK_EQ(node_id, static_cast<int>(cached_data_.size()));
+
+  cached_data_.push_back(TransformCachedNodeData());
+  return node_id;
+}
+
 void TransformTree::clear() {
   PropertyTree<TransformNode>::clear();
 
   nodes_affected_by_inner_viewport_bounds_delta_.clear();
   nodes_affected_by_outer_viewport_bounds_delta_.clear();
+  cached_data_.clear();
+  cached_data_.push_back(TransformCachedNodeData());
 }
 
 bool TransformTree::ComputeTransform(int source_id,
                                      int dest_id,
                                      gfx::Transform* transform) const {
   transform->MakeIdentity();
 
   if (source_id == dest_id)
     return true;
 
@@ skipping 52 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);
+      transform->ConcatTransform(FromScreen(dest->id));
     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 33 matching lines @@
                                            int dest_id,
                                            gfx::Transform* transform) const {
   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);
+    transform->PreconcatTransform(FromScreen(current->id));
     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 = ToScreen(parent_node->id);
     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))
+  gfx::Transform from_screen;
+  if (!ToScreen(node->id).GetInverse(&from_screen))
     node->data.ancestors_are_invertible = false;
+  SetFromScreen(node->id, from_screen);
 }
 
 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))
+  gfx::Transform from_target;
+  if (!target_space_transform.GetInverse(&from_target))
     node->data.ancestors_are_invertible = false;
+  SetToTarget(node->id, target_space_transform);
+  SetFromTarget(node->id, from_target);
 }
 
 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;
+  gfx::Transform delta = FromScreen(node->id);
   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());
-  node->data.from_target.matrix().postTranslate(-translation.x(),
-                                                -translation.y(), 0);
-
+  gfx::Transform from_screen = FromScreen(node->id);
+  from_screen.matrix().postTranslate(-translation.x(), -translation.y(), 0);
+  SetFromScreen(node->id, from_screen);
+  gfx::Transform to_target = ToTarget(node->id);
+  to_target.Translate(translation.x(), translation.y());
+  SetToTarget(node->id, to_target);
+  gfx::Transform from_target = FromTarget(node->id);
+  from_target.matrix().postTranslate(-translation.x(), -translation.y(), 0);
+  SetFromTarget(node->id, from_target);
   node->data.scroll_snap = translation;
 }
 
 void TransformTree::UpdateTransformChanged(TransformNode* node,
                                            TransformNode* parent_node,
                                            TransformNode* source_node) {
   if (parent_node && parent_node->data.transform_changed) {
     node->data.transform_changed = true;
     return;
   }
@@ skipping 79 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();
 }
 
+const gfx::Transform& TransformTree::FromTarget(int node_id) const {
+  DCHECK(static_cast<int>(cached_data_.size()) > node_id);
+  return cached_data_[node_id].from_target;
+}
+
+void TransformTree::SetFromTarget(int node_id,
+                                  const gfx::Transform& transform) {
+  DCHECK(static_cast<int>(cached_data_.size()) > node_id);
+  cached_data_[node_id].from_target = transform;
+}
+
+const gfx::Transform& TransformTree::ToTarget(int node_id) const {
+  DCHECK(static_cast<int>(cached_data_.size()) > node_id);
+  return cached_data_[node_id].to_target;
+}
+
+void TransformTree::SetToTarget(int node_id, const gfx::Transform& transform) {
+  DCHECK(static_cast<int>(cached_data_.size()) > node_id);
+  cached_data_[node_id].to_target = transform;
+}
+
+const gfx::Transform& TransformTree::FromScreen(int node_id) const {
+  DCHECK(static_cast<int>(cached_data_.size()) > node_id);
+  return cached_data_[node_id].from_screen;
+}
+
+void TransformTree::SetFromScreen(int node_id,
+                                  const gfx::Transform& transform) {
+  DCHECK(static_cast<int>(cached_data_.size()) > node_id);
+  cached_data_[node_id].from_screen = transform;
+}
+
+const gfx::Transform& TransformTree::ToScreen(int node_id) const {
+  DCHECK(static_cast<int>(cached_data_.size()) > node_id);
+  return cached_data_[node_id].to_screen;
+}
+
+void TransformTree::SetToScreen(int node_id, const gfx::Transform& transform) {
+  DCHECK(static_cast<int>(cached_data_.size()) > node_id);
+  cached_data_[node_id].to_screen = transform;
+}
+
+int TransformTree::TargetId(int node_id) const {
+  DCHECK(static_cast<int>(cached_data_.size()) > node_id);
+  return cached_data_[node_id].target_id;
+}
+
+void TransformTree::SetTargetId(int node_id, int target_id) {
+  DCHECK(static_cast<int>(cached_data_.size()) > node_id);
+  cached_data_[node_id].target_id = target_id;
+}
+
+int TransformTree::ContentTargetId(int node_id) const {
+  DCHECK(static_cast<int>(cached_data_.size()) > node_id);
+  return cached_data_[node_id].content_target_id;
+}
+
+void TransformTree::SetContentTargetId(int node_id, int content_target_id) {
+  DCHECK(static_cast<int>(cached_data_.size()) > node_id);
+  cached_data_[node_id].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_ ==
              other.source_to_parent_updates_allowed() &&
          page_scale_factor_ == other.page_scale_factor() &&
          device_scale_factor_ == other.device_scale_factor() &&
          device_transform_scale_factor_ ==
              other.device_transform_scale_factor() &&
          nodes_affected_by_inner_viewport_bounds_delta_ ==
              other.nodes_affected_by_inner_viewport_bounds_delta() &&
          nodes_affected_by_outer_viewport_bounds_delta_ ==
-             other.nodes_affected_by_outer_viewport_bounds_delta();
+             other.nodes_affected_by_outer_viewport_bounds_delta() &&
+         cached_data_ == other.cached_data();
 }
 
 void TransformTree::ToProtobuf(proto::PropertyTree* proto) const {
   DCHECK(!proto->has_property_type());
   proto->set_property_type(proto::PropertyTree::Transform);
 
   PropertyTree::ToProtobuf(proto);
   proto::TransformTreeData* data = proto->mutable_transform_tree_data();
 
   data->set_source_to_parent_updates_allowed(source_to_parent_updates_allowed_);
   data->set_page_scale_factor(page_scale_factor_);
   data->set_device_scale_factor(device_scale_factor_);
   data->set_device_transform_scale_factor(device_transform_scale_factor_);
 
   for (auto i : nodes_affected_by_inner_viewport_bounds_delta_)
     data->add_nodes_affected_by_inner_viewport_bounds_delta(i);
 
   for (auto i : nodes_affected_by_outer_viewport_bounds_delta_)
     data->add_nodes_affected_by_outer_viewport_bounds_delta(i);
+
+  for (int i = 0; i < static_cast<int>(cached_data_.size()); ++i)
+    cached_data_[i].ToProtobuf(data->add_cached_data());
 }
 
 void TransformTree::FromProtobuf(
     const proto::PropertyTree& proto,
     std::unordered_map<int, int>* node_id_to_index_map) {
   DCHECK(proto.has_property_type());
   DCHECK_EQ(proto.property_type(), proto::PropertyTree::Transform);
 
   PropertyTree::FromProtobuf(proto, node_id_to_index_map);
   const proto::TransformTreeData& data = proto.transform_tree_data();
 
   source_to_parent_updates_allowed_ = data.source_to_parent_updates_allowed();
   page_scale_factor_ = data.page_scale_factor();
   device_scale_factor_ = data.device_scale_factor();
   device_transform_scale_factor_ = data.device_transform_scale_factor();
 
   DCHECK(nodes_affected_by_inner_viewport_bounds_delta_.empty());
   for (int i = 0; i < data.nodes_affected_by_inner_viewport_bounds_delta_size();
        ++i) {
     nodes_affected_by_inner_viewport_bounds_delta_.push_back(
         data.nodes_affected_by_inner_viewport_bounds_delta(i));
   }
 
   DCHECK(nodes_affected_by_outer_viewport_bounds_delta_.empty());
   for (int i = 0; i < data.nodes_affected_by_outer_viewport_bounds_delta_size();
        ++i) {
     nodes_affected_by_outer_viewport_bounds_delta_.push_back(
         data.nodes_affected_by_outer_viewport_bounds_delta(i));
   }
+
+  // delete the node created when initializing transform tree

[ajuma, 2016/06/07 20:39:19]

This comment is now obsolete.

+  DCHECK_EQ(static_cast<int>(cached_data_.size()), 1);
+  cached_data_.back().FromProtobuf(data.cached_data(0));
+  for (int i = 1; i < data.cached_data_size(); ++i) {
+    cached_data_.push_back(TransformCachedNodeData());
+    cached_data_.back().FromProtobuf(data.cached_data(i));
+  }
 }
 
 EffectTree::EffectTree() {}
 
 EffectTree::~EffectTree() {}
 
 float EffectTree::EffectiveOpacity(const EffectNode* node) const {
   return node->data.subtree_hidden ? 0.f : node->data.opacity;
 }
 
@@ skipping 49 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