cc: Clean up transform tree

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 601d8f8ccad6b356f481df251ad0f6cb9e836667..dcee6146177efae08438ab21459f195d7bd0c42c 100644
--- a/cc/trees/draw_property_utils.cc
+++ b/cc/trees/draw_property_utils.cc
@@ -53,26 +53,6 @@ static void ValidateRenderSurfaceForLayer(LayerImpl* layer) {
   DCHECK(effect_node->filters.IsEmpty());
   DCHECK(effect_node->background_filters.IsEmpty());
 }
-
-void VerifySurfaceContentsScalesMatch(const int target_effect_id,
-                                      const int target_transform_id,
-                                      const EffectTree& effect_tree,
-                                      const TransformTree& transform_tree) {
-  if (target_effect_id == EffectTree::kInvalidNodeId) {
-    // This can happen when PaintArtifactCompositor builds property trees as it
-    // doesn't set effect ids on clip nodes.
-    return;
-  }
-  const TransformNode* target_transform_node =
-      transform_tree.Node(target_transform_id);
-  const EffectNode* target_effect_node = effect_tree.Node(target_effect_id);
-  DCHECK(target_transform_node->surface_contents_scale ==
-         target_effect_node->surface_contents_scale)
-      << " surface contents scale from transform tree: "
-      << target_transform_node->surface_contents_scale.ToString()
-      << " surface contents scale from effect tree: "
-      << target_effect_node->surface_contents_scale.ToString();
-}
 #endif
 
 static const EffectNode* ContentsTargetEffectNode(
@@ -106,25 +86,11 @@ bool ComputeClipRectInTargetSpace(const LayerImpl* layer,
     // In this case, layer has a scroll parent. We need to keep the scale
     // at the layer's target but remove the scale at the scroll parent's
     // target.
-    if (property_trees->ComputeTransformToTarget(clip_node->target_transform_id,
-                                                 target_effect_node->id,
-                                                 &clip_to_target)) {
-      PostConcatSurfaceContentsScale(target_effect_node, &clip_to_target);
-#if DCHECK_IS_ON()
-      const TransformTree& transform_tree = property_trees->transform_tree;
-      VerifySurfaceContentsScalesMatch(layer->effect_tree_index(),
-                                       target_node_id, effect_tree,
-                                       transform_tree);
-#endif
-
+    if (property_trees->GetToTarget(clip_node->target_transform_id,
+                                    target_effect_node->id, &clip_to_target)) {
       const EffectNode* source_node =
           effect_tree.Node(clip_node->target_effect_id);
       ConcatInverseSurfaceContentsScale(source_node, &clip_to_target);
-#if DCHECK_IS_ON()
-      VerifySurfaceContentsScalesMatch(clip_node->target_effect_id,
-                                       clip_node->target_transform_id,
-                                       effect_tree, transform_tree);
-#endif
       *clip_rect_in_target_space =
           MathUtil::MapClippedRect(clip_to_target, clip_from_clip_node);
     } else {
@@ -178,19 +144,11 @@ static ConditionalClip ComputeLocalRectInTargetSpace(
     int target_transform_id,
     int target_effect_id) {
   gfx::Transform current_to_target;
-  if (!property_trees->ComputeTransformToTarget(
-          current_transform_id, target_effect_id, &current_to_target)) {
+  if (!property_trees->GetToTarget(current_transform_id, target_effect_id,
+                                   &current_to_target)) {
     // If transform is not invertible, cannot apply clip.
     return ConditionalClip{false, gfx::RectF()};
   }
-  const EffectTree& effect_tree = property_trees->effect_tree;
-  const EffectNode* target_effect_node = effect_tree.Node(target_effect_id);
-  PostConcatSurfaceContentsScale(target_effect_node, &current_to_target);
-#if DCHECK_IS_ON()
-  const TransformTree& transform_tree = property_trees->transform_tree;
-  VerifySurfaceContentsScalesMatch(target_effect_id, target_transform_id,
-                                   effect_tree, transform_tree);
-#endif
 
   if (current_transform_id > target_transform_id)
     return ConditionalClip{true,  // is_clipped.
@@ -490,8 +448,10 @@ void CalculateVisibleRects(const LayerImplList& visible_layer_list,
     }
 
     // The clip rect should be intersected with layer rect in target space.
-    gfx::Transform content_to_target = transform_tree.ToTarget(
-        transform_node->id, layer->render_target_effect_tree_index());
+    gfx::Transform content_to_target;
+    property_trees->GetToTarget(transform_node->id,
+                                layer->render_target_effect_tree_index(),
+                                &content_to_target);
     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);
@@ -515,8 +475,9 @@ void CalculateVisibleRects(const LayerImplList& visible_layer_list,
 
     gfx::Transform target_to_layer;
     if (transform_node->ancestors_are_invertible) {
-      target_to_layer = transform_tree.FromTarget(
-          transform_node->id, layer->render_target_effect_tree_index());
+      property_trees->GetFromTarget(transform_node->id,
+                                    layer->render_target_effect_tree_index(),
+                                    &target_to_layer);
     } else {
       const EffectNode* target_effect_node =
           ContentsTargetEffectNode(layer->effect_tree_index(), effect_tree);
@@ -530,10 +491,6 @@ void CalculateVisibleRects(const LayerImplList& visible_layer_list,
         continue;
       }
       ConcatInverseSurfaceContentsScale(target_effect_node, &target_to_layer);
-#if DCHECK_IS_ON()
-      VerifySurfaceContentsScalesMatch(target_effect_node->id, target_node_id,
-                                       effect_tree, transform_tree);
-#endif
     }
     gfx::Transform target_to_content;
     target_to_content.Translate(-layer->offset_to_transform_parent().x(),
@@ -562,31 +519,36 @@ static int TransformTreeIndexForBackfaceVisibility(LayerType* layer,
   return layer->id() == node->owner_id ? tree.parent(node)->id : node->id;
 }
 
-static bool IsTargetSpaceTransformBackFaceVisible(Layer* layer,
-                                                  int transform_tree_index,
-                                                  const TransformTree& tree) {
+static bool IsTargetSpaceTransformBackFaceVisible(
+    Layer* layer,
+    int transform_tree_index,
+    const PropertyTrees* property_trees) {
   // We do not skip back face invisible layers on main thread as target space
   // transform will not be available here.
   return false;
 }
 
-static bool IsTargetSpaceTransformBackFaceVisible(LayerImpl* layer,
-                                                  int transform_tree_index,
-                                                  const TransformTree& tree) {
-  return tree
-      .ToTarget(transform_tree_index, layer->render_target_effect_tree_index())
-      .IsBackFaceVisible();
+static bool IsTargetSpaceTransformBackFaceVisible(
+    LayerImpl* layer,
+    int transform_tree_index,
+    const PropertyTrees* property_trees) {
+  gfx::Transform to_target;
+  property_trees->GetToTarget(transform_tree_index,
+                              layer->render_target_effect_tree_index(),
+                              &to_target);
+  return to_target.IsBackFaceVisible();
 }
 
 template <typename LayerType>
 static bool IsLayerBackFaceVisible(LayerType* layer,
                                    int transform_tree_index,
-                                   const TransformTree& tree) {
-  const TransformNode* node = tree.Node(transform_tree_index);
+                                   const PropertyTrees* property_trees) {
+  const TransformNode* node =
+      property_trees->transform_tree.Node(transform_tree_index);
   return layer->use_local_transform_for_backface_visibility()
              ? node->local.IsBackFaceVisible()
              : IsTargetSpaceTransformBackFaceVisible(
-                   layer, transform_tree_index, tree);
+                   layer, transform_tree_index, property_trees);
 }
 
 static inline bool TransformToScreenIsKnown(Layer* layer,
@@ -605,7 +567,7 @@ static inline bool TransformToScreenIsKnown(LayerImpl* layer,
 template <typename LayerType>
 static bool LayerNeedsUpdateInternal(LayerType* layer,
                                      bool layer_is_drawn,
-                                     const TransformTree& tree) {
+                                     const PropertyTrees* property_trees) {
   // Layers can be skipped if any of these conditions are met.
   //   - is not drawn due to it or one of its ancestors being hidden (or having
   //     no copy requests).
@@ -630,6 +592,7 @@ static bool LayerNeedsUpdateInternal(LayerType* layer,
 
   // The layer should not be drawn if (1) it is not double-sided and (2) the
   // back of the layer is known to be facing the screen.
+  const TransformTree& tree = property_trees->transform_tree;
   if (layer->should_check_backface_visibility()) {
     int backface_transform_id =
         TransformTreeIndexForBackfaceVisibility(layer, tree);
@@ -637,7 +600,7 @@ static bool LayerNeedsUpdateInternal(LayerType* layer,
     // backface is not visible.
     if (TransformToScreenIsKnown(layer, backface_transform_id, tree) &&
         !HasSingularTransform(backface_transform_id, tree) &&
-        IsLayerBackFaceVisible(layer, backface_transform_id, tree))
+        IsLayerBackFaceVisible(layer, backface_transform_id, property_trees))
       return false;
   }
 
@@ -645,9 +608,11 @@ static bool LayerNeedsUpdateInternal(LayerType* layer,
 }
 
 void FindLayersThatNeedUpdates(LayerTreeImpl* layer_tree_impl,
-                               const TransformTree& transform_tree,
-                               const EffectTree& effect_tree,
+                               const PropertyTrees* property_trees,
                                std::vector<LayerImpl*>* visible_layer_list) {
+  const TransformTree& transform_tree = property_trees->transform_tree;
+  const EffectTree& effect_tree = property_trees->effect_tree;
+
   for (auto* layer_impl : *layer_tree_impl) {
     bool layer_is_drawn =
         effect_tree.Node(layer_impl->effect_tree_index())->is_drawn;
@@ -657,7 +622,7 @@ void FindLayersThatNeedUpdates(LayerTreeImpl* layer_tree_impl,
                              effect_tree))
       continue;
 
-    if (LayerNeedsUpdate(layer_impl, layer_is_drawn, transform_tree))
+    if (LayerNeedsUpdate(layer_impl, layer_is_drawn, property_trees))
       visible_layer_list->push_back(layer_impl);
   }
 }
@@ -717,9 +682,10 @@ bool LayerShouldBeSkipped(Layer* layer,
 }
 
 void FindLayersThatNeedUpdates(LayerTree* layer_tree,
-                               const TransformTree& transform_tree,
-                               const EffectTree& effect_tree,
+                               const PropertyTrees* property_trees,
                                LayerList* update_layer_list) {
+  const TransformTree& transform_tree = property_trees->transform_tree;
+  const EffectTree& effect_tree = property_trees->effect_tree;
   for (auto* layer : *layer_tree) {
     bool layer_is_drawn =
         effect_tree.Node(layer->effect_tree_index())->is_drawn;
@@ -729,7 +695,7 @@ void FindLayersThatNeedUpdates(LayerTree* layer_tree,
                              effect_tree))
       continue;
 
-    if (LayerNeedsUpdate(layer, layer_is_drawn, transform_tree)) {
+    if (LayerNeedsUpdate(layer, layer_is_drawn, property_trees)) {
       update_layer_list->push_back(layer);
     }
 
@@ -815,20 +781,10 @@ void ComputeClips(PropertyTrees* property_trees,
       const EffectNode* target_effect_node =
           effect_tree.Node(clip_node->target_effect_id);
       PostConcatSurfaceContentsScale(target_effect_node, &parent_to_current);
-#if DCHECK_IS_ON()
-      VerifySurfaceContentsScalesMatch(clip_node->target_effect_id,
-                                       clip_node->target_transform_id,
-                                       effect_tree, transform_tree);
-#endif
       const EffectNode* parent_target_effect_node =
           effect_tree.Node(parent_clip_node->target_effect_id);
       ConcatInverseSurfaceContentsScale(parent_target_effect_node,
                                         &parent_to_current);
-#if DCHECK_IS_ON()
-      VerifySurfaceContentsScalesMatch(parent_clip_node->target_effect_id,
-                                       parent_clip_node->target_transform_id,
-                                       effect_tree, transform_tree);
-#endif
       // If we can't compute a transform, it's because we had to use the inverse
       // of a singular transform. We won't draw in this case, so there's no need
       // to compute clips.
@@ -846,10 +802,11 @@ void ComputeClips(PropertyTrees* property_trees,
     // it will be lost.
     if (clip_node->resets_clip && non_root_surfaces_enabled) {
       if (clip_node->clip_type == ClipNode::ClipType::APPLIES_LOCAL_CLIP) {
-        clip_node->clip_in_target_space = MathUtil::MapClippedRect(
-            transform_tree.ToTarget(clip_node->transform_id,
-                                    clip_node->target_effect_id),
-            clip_node->clip);
+        gfx::Transform to_target;
+        property_trees->GetToTarget(clip_node->transform_id,
+                                    clip_node->target_effect_id, &to_target);
+        clip_node->clip_in_target_space =
+            MathUtil::MapClippedRect(to_target, clip_node->clip);
         ResetIfHasNanCoordinate(&clip_node->clip_in_target_space);
         clip_node->combined_clip_in_target_space =
             gfx::IntersectRects(clip_node->clip_in_target_space,
@@ -886,19 +843,12 @@ void ComputeClips(PropertyTrees* property_trees,
         source_to_target = transform_tree.ToScreen(clip_node->transform_id);
       } else if (transform_tree.ContentTargetId(transform_node->id) ==
                  clip_node->target_transform_id) {
-        source_to_target = transform_tree.ToTarget(clip_node->transform_id,
-                                                   clip_node->target_effect_id);
+        property_trees->GetToTarget(clip_node->transform_id,
+                                    clip_node->target_effect_id,
+                                    &source_to_target);
       } else {
-        success = property_trees->ComputeTransformToTarget(
+        success = property_trees->GetToTarget(
             transform_node->id, clip_node->target_effect_id, &source_to_target);
-        const EffectNode* target_effect_node =
-            effect_tree.Node(clip_node->target_effect_id);
-        PostConcatSurfaceContentsScale(target_effect_node, &source_to_target);
-#if DCHECK_IS_ON()
-        VerifySurfaceContentsScalesMatch(clip_node->target_effect_id,
-                                         clip_node->target_transform_id,
-                                         effect_tree, transform_tree);
-#endif
         // source_to_target computation should be successful as target is an
         // ancestor of the transform node.
         DCHECK(success);
@@ -1033,47 +983,6 @@ static void ComputeLayerClipRect(const PropertyTrees* property_trees,
   }
 }
 
-static int FindTargetTransformTreeIndexFromEffectTree(
-    const EffectTree& effect_tree,
-    const int effect_tree_index) {
-  const EffectNode* node = effect_tree.Node(effect_tree_index);
-  if (node->has_render_surface)
-    return node->transform_id;
-  node = effect_tree.Node(node->target_id);
-  return node->transform_id;
-}
-
-static void VerifyDrawTransformsMatch(LayerImpl* layer,
-                                      PropertyTrees* property_trees) {
-  const int source_id = layer->transform_tree_index();
-  int destination_id = FindTargetTransformTreeIndexFromEffectTree(
-      property_trees->effect_tree, layer->effect_tree_index());
-  const EffectNode* target_effect_node = ContentsTargetEffectNode(
-      layer->effect_tree_index(), property_trees->effect_tree);
-  gfx::Transform draw_transform;
-  property_trees->ComputeTransformToTarget(source_id, target_effect_node->id,
-                                           &draw_transform);
-  PostConcatSurfaceContentsScale(target_effect_node, &draw_transform);
-#if DCHECK_IS_ON()
-  VerifySurfaceContentsScalesMatch(layer->effect_tree_index(), destination_id,
-                                   property_trees->effect_tree,
-                                   property_trees->transform_tree);
-#endif
-  if (layer->should_flatten_transform_from_property_tree())
-    draw_transform.FlattenTo2d();
-  draw_transform.Translate(layer->offset_to_transform_parent().x(),
-                           layer->offset_to_transform_parent().y());
-  DCHECK(draw_transform.ApproximatelyEqual(DrawTransform(
-      layer, property_trees->transform_tree, property_trees->effect_tree)))
-      << " layer: " << layer->id() << " source transform id: " << source_id
-      << " destination transform id: " << destination_id
-      << " draw transform from transform tree: "
-      << DrawTransform(layer, property_trees->transform_tree,
-                       property_trees->effect_tree)
-             .ToString()
-      << " v.s." << draw_transform.ToString();
-}
-
 static void ComputeVisibleRectsInternal(
     LayerImpl* root_layer,
     PropertyTrees* property_trees,
@@ -1096,9 +1005,8 @@ static void ComputeVisibleRectsInternal(
   ComputeEffects(&property_trees->effect_tree);
   ComputeClips(property_trees, can_render_to_separate_surface);
 
-  FindLayersThatNeedUpdates(root_layer->layer_tree_impl(),
-                            property_trees->transform_tree,
-                            property_trees->effect_tree, visible_layer_list);
+  FindLayersThatNeedUpdates(root_layer->layer_tree_impl(), property_trees,
+                            visible_layer_list);
   CalculateClipRects(*visible_layer_list, property_trees,
                      can_render_to_separate_surface);
   CalculateVisibleRects(*visible_layer_list, property_trees,
@@ -1155,12 +1063,6 @@ void VerifyClipTreeCalculations(const LayerImplList& layer_list,
     ComputeLayerClipRect(property_trees, layer);
 }
 
-void VerifyTransformTreeCalculations(const LayerImplList& layer_list,
-                                     PropertyTrees* property_trees) {
-  for (auto* layer : layer_list)
-    VerifyDrawTransformsMatch(layer, property_trees);
-}
-
 void ComputeVisibleRects(LayerImpl* root_layer,
                          PropertyTrees* property_trees,
                          bool can_render_to_separate_surface,
@@ -1239,14 +1141,14 @@ void VerifyVisibleRectsCalculations(const LayerImplList& layer_list,
 
 bool LayerNeedsUpdate(Layer* layer,
                       bool layer_is_drawn,
-                      const TransformTree& tree) {
-  return LayerNeedsUpdateInternal(layer, layer_is_drawn, tree);
+                      const PropertyTrees* property_trees) {
+  return LayerNeedsUpdateInternal(layer, layer_is_drawn, property_trees);
 }
 
 bool LayerNeedsUpdate(LayerImpl* layer,
                       bool layer_is_drawn,
-                      const TransformTree& tree) {
-  return LayerNeedsUpdateInternal(layer, layer_is_drawn, tree);
+                      const PropertyTrees* property_trees) {
+  return LayerNeedsUpdateInternal(layer, layer_is_drawn, property_trees);
 }
 
 gfx::Transform DrawTransform(const LayerImpl* layer,
@@ -1255,11 +1157,13 @@ gfx::Transform DrawTransform(const LayerImpl* layer,
   // TransformTree::ToTarget computes transform between the layer's transform
   // node and surface's transform node and scales it by the surface's content
   // scale.
-  gfx::Transform xform =
-      transform_tree.property_trees()->non_root_surfaces_enabled
-          ? transform_tree.ToTarget(layer->transform_tree_index(),
-                                    layer->render_target_effect_tree_index())
-          : transform_tree.ToScreen(layer->transform_tree_index());
+  gfx::Transform xform;
+  if (transform_tree.property_trees()->non_root_surfaces_enabled)
+    transform_tree.property_trees()->GetToTarget(
+        layer->transform_tree_index(), layer->render_target_effect_tree_index(),
+        &xform);
+  else
+    xform = transform_tree.ToScreen(layer->transform_tree_index());
   if (layer->should_flatten_transform_from_property_tree())
     xform.FlattenTo2d();
   xform.Translate(layer->offset_to_transform_parent().x(),
@@ -1284,22 +1188,10 @@ static void SetSurfaceDrawTransform(const PropertyTrees* property_trees,
   gfx::Transform render_surface_transform;
   const EffectNode* target_effect_node =
       effect_tree.Node(effect_node->target_id);
-  property_trees->ComputeTransformToTarget(
-      transform_node->id, target_effect_node->id, &render_surface_transform);
-  PostConcatSurfaceContentsScale(target_effect_node, &render_surface_transform);
-#if DCHECK_IS_ON()
-  const TransformNode* target_transform_node =
-      transform_tree.Node(transform_tree.TargetId(transform_node->id));
-  VerifySurfaceContentsScalesMatch(effect_node->target_id,
-                                   target_transform_node->id, effect_tree,
-                                   transform_tree);
-#endif
+  property_trees->GetToTarget(transform_node->id, target_effect_node->id,
+                              &render_surface_transform);
 
   ConcatInverseSurfaceContentsScale(effect_node, &render_surface_transform);
-#if DCHECK_IS_ON()
-  VerifySurfaceContentsScalesMatch(effect_node->id, transform_node->id,
-                                   effect_tree, transform_tree);
-#endif
   render_surface->SetDrawTransform(render_surface_transform);
 }
 
@@ -1337,7 +1229,7 @@ static void SetSurfaceClipRect(const ClipNode* parent_clip_node,
   const EffectNode* effect_node =
       effect_tree.Node(render_surface->EffectTreeIndex());
   int target_effect_id = effect_node->target_id;
-  const bool success = property_trees->ComputeTransformToTarget(
+  const bool success = property_trees->GetToTarget(
       parent_clip_node->target_transform_id, target_effect_id,
       &clip_parent_target_to_target);
 
@@ -1346,13 +1238,6 @@ static void SetSurfaceClipRect(const ClipNode* parent_clip_node,
     return;
   }
 
-  PostConcatSurfaceContentsScale(effect_node, &clip_parent_target_to_target);
-#if DCHECK_IS_ON()
-  VerifySurfaceContentsScalesMatch(render_surface->EffectTreeIndex(),
-                                   transform_tree.TargetId(transform_node->id),
-                                   effect_tree, transform_tree);
-#endif
-
   DCHECK_LT(parent_clip_node->target_transform_id,
             transform_tree.TargetId(transform_node->id));
   render_surface->SetClipRect(gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(