cc: Remove usage of Layer draw_transform

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 778 matching lines @@
     if (can_render_to_separate_surface)
       ValidateRenderSurfaceForLayer(layer);
 #endif
   }
   LayerImplList update_layer_list;
   ComputeVisibleRectsInternal(root_layer, property_trees,
                               can_render_to_separate_surface,
                               &update_layer_list, visible_layer_list);
 }
 
-template <typename LayerType>
-static gfx::Transform DrawTransformInternal(const LayerType* layer,
-                                            const TransformNode* node) {
+gfx::Transform DrawTransform(const LayerImpl* layer,
+                             const TransformTree& tree) {
+  const TransformNode* node = tree.Node(layer->transform_tree_index());
   gfx::Transform xform;
   const bool owns_non_root_surface =
       !IsRootLayer(layer) && layer->has_render_surface();
   if (!owns_non_root_surface) {
     // If you're not the root, or you don't own a surface, you need to apply
     // your local offset.
     xform = node->data.to_target;
     if (layer->should_flatten_transform_from_property_tree())
       xform.FlattenTo2d();
     xform.Translate(layer->offset_to_transform_parent().x(),
                     layer->offset_to_transform_parent().y());
   } else {
     // Surfaces need to apply their sublayer scale.
     xform.Scale(node->data.sublayer_scale.x(), node->data.sublayer_scale.y());
   }
   return xform;
 }
 
-gfx::Transform DrawTransform(const Layer* layer, const TransformTree& tree) {
-  return DrawTransformInternal(layer, tree.Node(layer->transform_tree_index()));
-}
-
-gfx::Transform DrawTransform(const LayerImpl* layer,
-                             const TransformTree& tree) {
-  return DrawTransformInternal(layer, tree.Node(layer->transform_tree_index()));
-}
-
 static void SetSurfaceDrawTransform(const TransformTree& tree,
                                     RenderSurfaceImpl* render_surface) {
   const TransformNode* node = tree.Node(render_surface->TransformTreeIndex());
   // The draw transform of root render surface is identity tranform.
   if (node->id == 1) {
     render_surface->SetDrawTransform(gfx::Transform());
     return;
   }
 
   gfx::Transform render_surface_transform;
@@ skipping 178 matching lines @@
       property_trees->transform_tree.Node(layer->transform_tree_index());
   const EffectNode* effect_node =
       property_trees->effect_tree.Node(layer->effect_tree_index());
   const ClipNode* clip_node =
       property_trees->clip_tree.Node(layer->clip_tree_index());
 
   layer->draw_properties().screen_space_transform =
       ScreenSpaceTransformInternal(layer, transform_node);
   if (property_trees->non_root_surfaces_enabled) {
     layer->draw_properties().target_space_transform =
-        DrawTransformInternal(layer, transform_node);
+        DrawTransform(layer, property_trees->transform_tree);
   } else {
     layer->draw_properties().target_space_transform =
         layer->draw_properties().screen_space_transform;
   }
   layer->draw_properties().screen_space_transform_is_animating =
       transform_node->data.to_screen_is_animated;
   if (layer->layer_tree_impl()
           ->settings()
           .layer_transforms_should_scale_layer_contents) {
     layer->draw_properties().maximum_animation_contents_scale =
@@ skipping 138 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