cc: Clean up transform tree

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 35 matching lines @@
   EffectNode* effect_node =
       layer->layer_tree_impl()->property_trees()->effect_tree.Node(
           layer->effect_tree_index());
   if (effect_node->owner_id != layer->id())
     return;
   DCHECK_EQ(effect_node->mask_layer_id, EffectTree::kInvalidNodeId)
       << "layer: " << layer->id();
   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(
     const int effect_tree_index,
     const EffectTree& effect_tree) {
   const EffectNode* effect_node = effect_tree.Node(effect_tree_index);
   return effect_node->render_surface ? effect_node
                                      : effect_tree.Node(effect_node->target_id);
 }
 
@@ skipping 13 matching lines @@
   // We use the local clip for clip rect calculation and combined clip for
   // visible rect calculation.
   gfx::RectF clip_from_clip_node =
       for_visible_rect_calculation ? clip_node->combined_clip_in_target_space
                                    : clip_node->clip_in_target_space;
 
   if (clip_node->target_transform_id > target_node_id) {
     // 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 {
       return false;
     }
   } else {
     if (property_trees->ComputeTransformFromTarget(
             target_node_id, clip_node->target_effect_id, &clip_to_target)) {
       *clip_rect_in_target_space =
           MathUtil::ProjectClippedRect(clip_to_target, clip_from_clip_node);
@@ skipping 33 matching lines @@
                          MathUtil::ProjectClippedRect(target_to_local, rect)};
 }
 
 static ConditionalClip ComputeLocalRectInTargetSpace(
     gfx::RectF rect,
     const PropertyTrees* property_trees,
     int current_transform_id,
     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.
                            MathUtil::MapClippedRect(current_to_target, rect)};
 
   return ConditionalClip{true,  // is_clipped.
                          MathUtil::ProjectClippedRect(current_to_target, rect)};
 }
 
 static ConditionalClip ComputeCurrentClip(const ClipNode* clip_node,
@@ skipping 279 matching lines @@
                                         &combined_clip_rect_in_target_space)) {
         layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
         continue;
       }
     } else {
       combined_clip_rect_in_target_space =
           clip_node->combined_clip_in_target_space;
     }
 
     // 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);
     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->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);
       bool success = property_trees->ComputeTransformFromTarget(
           transform_node->id, target_effect_node->id, &target_to_layer);
       if (!success) {
         // 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;
       }
       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(),
                                 -layer->offset_to_transform_parent().y());
     target_to_content.PreconcatTransform(target_to_layer);
 
     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);
   }
 }
 
 static bool HasSingularTransform(int transform_tree_index,
                                  const TransformTree& tree) {
   const TransformNode* node = tree.Node(transform_tree_index);
   return !node->is_invertible || !node->ancestors_are_invertible;
 }
 
 template <typename LayerType>
 static int TransformTreeIndexForBackfaceVisibility(LayerType* layer,
                                                    const TransformTree& tree) {
   if (!layer->use_parent_backface_visibility())
     return layer->transform_tree_index();
   const TransformNode* node = tree.Node(layer->transform_tree_index());
   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,
                                             int transform_tree_index,
                                             const TransformTree& tree) {
   const TransformNode* node = tree.Node(transform_tree_index);
   return !node->to_screen_is_potentially_animated;
 }
 
 static inline bool TransformToScreenIsKnown(LayerImpl* layer,
                                             int transform_tree_index,
                                             const TransformTree& tree) {
   return true;
 }
 
 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).
   //   - does not draw content.
   //   - is transparent.
   //   - has empty bounds
   //   - the layer is not double-sided, but its back face is visible.
   //
   // Some additional conditions need to be computed at a later point after the
   // recursion is finished.
   //   - the intersection of render_surface content and layer clip_rect is empty
   //   - the visible_layer_rect is empty
   //
   // Note, if the layer should not have been drawn due to being fully
   // transparent, we would have skipped the entire subtree and never made it
   // into this function, so it is safe to omit this check here.
   if (!layer_is_drawn)
     return false;
 
   if (!layer->DrawsContent() || layer->bounds().IsEmpty())
     return false;
 
   // 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);
     // A layer with singular transform is not drawn. So, we can assume that its
     // 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;
   }
 
   return true;
 }
 
 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;
 
     if (!IsRootLayer(layer_impl) &&
         LayerShouldBeSkipped(layer_impl, layer_is_drawn, transform_tree,
                              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);
   }
 }
 
 void UpdateRenderSurfaceForLayer(EffectTree* effect_tree,
                                  bool non_root_surfaces_enabled,
                                  LayerImpl* layer) {
   if (!non_root_surfaces_enabled) {
     layer->SetHasRenderSurface(IsRootLayer(layer));
     return;
@@ skipping 39 matching lines @@
 
 bool LayerShouldBeSkipped(Layer* layer,
                           bool layer_is_drawn,
                           const TransformTree& transform_tree,
                           const EffectTree& effect_tree) {
   return LayerShouldBeSkippedInternal(layer, layer_is_drawn, transform_tree,
                                       effect_tree);
 }
 
 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;
 
     if (!IsRootLayer(layer) &&
         LayerShouldBeSkipped(layer, layer_is_drawn, transform_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);
     }
 
     // Append mask layers to the update layer list. They don't have valid
     // visible rects, so need to get added after the above calculation.
     if (Layer* mask_layer = layer->mask_layer())
       update_layer_list->push_back(mask_layer);
   }
 }
 
@@ skipping 65 matching lines @@
         parent_clip_node->clip_in_target_space;
     if (parent_target_transform_node &&
         parent_target_transform_node->id != clip_node->target_transform_id &&
         non_root_surfaces_enabled) {
       success &= property_trees->ComputeTransformFromTarget(
           clip_node->target_transform_id, parent_clip_node->target_effect_id,
           &parent_to_current);
       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.
       if (!success)
         continue;
       parent_combined_clip_in_target_space = MathUtil::ProjectClippedRect(
           parent_to_current, parent_clip_node->combined_clip_in_target_space);
       parent_clip_in_target_space = MathUtil::ProjectClippedRect(
           parent_to_current, parent_clip_node->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->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,
                                 parent_combined_clip_in_target_space);
       } else {
         DCHECK(!clip_node->target_is_clipped);
         DCHECK(!clip_node->layers_are_clipped);
         clip_node->combined_clip_in_target_space =
             parent_combined_clip_in_target_space;
       }
@@ skipping 16 matching lines @@
         // it to an empty rect.
         clip_node->clip_in_target_space = gfx::RectF();
       }
     } else {
       gfx::Transform source_to_target;
 
       if (!non_root_surfaces_enabled) {
         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);
       }
 
       gfx::RectF source_clip_in_target_space =
           MathUtil::MapClippedRect(source_to_target, clip_node->clip);
 
       // With surfaces disabled, the only case where we use only the local clip
       // for layer clipping is the case where no non-viewport ancestor node
@@ skipping 114 matching lines @@
         << " layer: " << layer->id() << " clip id: " << layer->clip_tree_index()
         << " layer clip: " << layer->clip_rect().ToString() << " v.s. "
         << gfx::ToEnclosingRect(accumulated_clip).ToString()
         << " and clip node clip: "
         << gfx::ToEnclosingRect(
                clip_tree->Node(layer->clip_tree_index())->clip_in_target_space)
                .ToString();
   }
 }
 
-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,
     bool can_render_to_separate_surface,
     std::vector<LayerImpl*>* visible_layer_list) {
   if (property_trees->non_root_surfaces_enabled !=
       can_render_to_separate_surface) {
     property_trees->non_root_surfaces_enabled = can_render_to_separate_surface;
     property_trees->transform_tree.set_needs_update(true);
   }
   if (property_trees->transform_tree.needs_update()) {
     property_trees->clip_tree.set_needs_update(true);
     property_trees->effect_tree.set_needs_update(true);
   }
   UpdateRenderTarget(&property_trees->effect_tree,
                      property_trees->non_root_surfaces_enabled);
   ComputeTransforms(&property_trees->transform_tree);
   // Computation of clips uses surface contents scale which is updated while
   // computing effects. So, ComputeEffects should be before ComputeClips.
   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,
                         can_render_to_separate_surface);
 }
 
 void UpdatePropertyTrees(PropertyTrees* property_trees,
                          bool can_render_to_separate_surface) {
   if (property_trees->non_root_surfaces_enabled !=
       can_render_to_separate_surface) {
@@ skipping 36 matching lines @@
 
 void VerifyClipTreeCalculations(const LayerImplList& layer_list,
                                 PropertyTrees* property_trees) {
   if (property_trees->non_root_surfaces_enabled) {
     ComputeClipsWithEffectTree(property_trees);
   }
   for (auto* layer : 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,
                          LayerImplList* visible_layer_list) {
   for (auto* layer : *root_layer->layer_tree_impl()) {
     UpdateRenderSurfaceForLayer(&property_trees->effect_tree,
                                 can_render_to_separate_surface, layer);
     EffectNode* node =
         property_trees->effect_tree.Node(layer->effect_tree_index());
     if (node->owner_id == layer->id())
@@ skipping 58 matching lines @@
     DCHECK(layer->visible_layer_rect() == visible_rect_dynamic)
         << " layer: " << layer->id() << " clip id: " << layer->clip_tree_index()
         << " visible rect cached: " << layer->visible_layer_rect().ToString()
         << " v.s. "
         << " visible rect dynamic: " << visible_rect_dynamic.ToString();
   }
 }
 
 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,
                              const TransformTree& transform_tree,
                              const EffectTree& effect_tree) {
   // 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(),
                   layer->offset_to_transform_parent().y());
   return xform;
 }
 
 static void SetSurfaceDrawTransform(const PropertyTrees* property_trees,
                                     RenderSurfaceImpl* render_surface) {
   const TransformTree& transform_tree = property_trees->transform_tree;
   const EffectTree& effect_tree = property_trees->effect_tree;
   const TransformNode* transform_node =
       transform_tree.Node(render_surface->TransformTreeIndex());
   const EffectNode* effect_node =
       effect_tree.Node(render_surface->EffectTreeIndex());
   // The draw transform of root render surface is identity tranform.
   if (transform_node->id == 1) {
     render_surface->SetDrawTransform(gfx::Transform());
     return;
   }
 
   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);
 }
 
 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->target_is_clipped);
 }
@@ skipping 17 matching lines @@
     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 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);
 
   if (!success) {
     render_surface->SetClipRect(gfx::Rect());
     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(
       clip_parent_target_to_target, parent_clip_node->clip_in_target_space)));
 }
 
 template <typename LayerType>
 static gfx::Transform ScreenSpaceTransformInternal(LayerType* layer,
                                                    const TransformTree& tree) {
   gfx::Transform xform(1, 0, 0, 1, layer->offset_to_transform_parent().x(),
@@ skipping 210 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