cc : Delete LayerImpl::transform

cc/trees/property_tree_builder.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/property_tree_builder.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
@@ skipping 216 matching lines @@
 }
 
 static Layer* ReplicaLayer(Layer* layer) {
   return layer->replica_layer();
 }
 
 static LayerImpl* ReplicaLayer(LayerImpl* layer) {
   return layer->test_properties()->replica_layer;
 }
 
+static const gfx::Transform& Transform(Layer* layer) {
+  return layer->transform();
+}
+
+static const gfx::Transform& Transform(LayerImpl* layer) {
+  return layer->test_properties()->transform;
+}
+
 // Methods to query state from the AnimationHost ----------------------
 template <typename LayerType>
 bool OpacityIsAnimating(LayerType* layer) {
   return layer->GetAnimationHost()->IsAnimatingOpacityProperty(
       layer->element_id(), layer->GetElementTypeForAnimation());
 }
 
 template <typename LayerType>
 bool HasPotentiallyRunningOpacityAnimation(LayerType* layer) {
   return layer->GetAnimationHost()->HasPotentiallyRunningOpacityAnimation(
@@ skipping 233 matching lines @@
     bool created_render_surface,
     DataForRecursion<LayerType>* data_for_children) {
   const bool is_root = !Parent(layer);
   const bool is_page_scale_layer = layer == data_from_ancestor.page_scale_layer;
   const bool is_overscroll_elasticity_layer =
       layer == data_from_ancestor.overscroll_elasticity_layer;
   const bool is_scrollable = layer->scrollable();
   const bool is_fixed = PositionConstraint(layer).is_fixed_position();
 
   const bool has_significant_transform =
-      !layer->transform().IsIdentityOr2DTranslation();
+      !Transform(layer).IsIdentityOr2DTranslation();
 
   const bool has_potentially_animated_transform =
       HasPotentiallyRunningTransformAnimation(layer);
 
   // A transform node is needed even for a finished animation, since differences
   // in the timing of animation state updates can mean that an animation that's
   // in the Finished state at tree-building time on the main thread is still in
   // the Running state right after commit on the compositor thread.
   const bool has_any_transform_animation =
       HasAnyAnimationTargetingProperty(layer, TargetProperty::TRANSFORM);
@@ skipping 46 matching lines @@
     }
   }
 
   if (IsContainerForFixedPositionLayers(layer) || is_root) {
     data_for_children->affected_by_inner_viewport_bounds_delta =
         layer == data_from_ancestor.inner_viewport_scroll_layer;
     data_for_children->affected_by_outer_viewport_bounds_delta =
         layer == data_from_ancestor.outer_viewport_scroll_layer;
     if (is_scrollable) {
       DCHECK(!is_root);
-      DCHECK(layer->transform().IsIdentity());
+      DCHECK(Transform(layer).IsIdentity());
       data_for_children->transform_fixed_parent = Parent(layer);
     } else {
       data_for_children->transform_fixed_parent = layer;
     }
   }
   data_for_children->transform_tree_parent = layer;
 
   if (!requires_node) {
     data_for_children->should_flatten |= ShouldFlattenTransform(layer);
     gfx::Vector2dF local_offset = layer->position().OffsetFromOrigin() +
-                                  layer->transform().To2dTranslation();
+                                  Transform(layer).To2dTranslation();
     gfx::Vector2dF source_to_parent;
     if (source_index != parent_index) {
       gfx::Transform to_parent;
       data_from_ancestor.property_trees->transform_tree.ComputeTranslation(
           source_index, parent_index, &to_parent);
       source_to_parent = to_parent.To2dTranslation();
     }
     layer->set_offset_to_transform_parent(source_offset + source_to_parent +
                                           local_offset);
     layer->set_should_flatten_transform_from_property_tree(
@@ skipping 97 matching lines @@
       node->affected_by_outer_viewport_bounds_delta_y =
           PositionConstraint(layer).is_fixed_to_bottom_edge();
       if (node->affected_by_outer_viewport_bounds_delta_x ||
           node->affected_by_outer_viewport_bounds_delta_y) {
         data_for_children->property_trees->transform_tree
             .AddNodeAffectedByOuterViewportBoundsDelta(node->id);
       }
     }
   }
 
-  node->local = layer->transform();
+  node->local = Transform(layer);
   node->update_pre_local_transform(TransformOrigin(layer));
 
   node->needs_local_transform_update = true;
   data_from_ancestor.property_trees->transform_tree.UpdateTransforms(node->id);
 
   layer->set_offset_to_transform_parent(gfx::Vector2dF());
 
   // Flattening (if needed) will be handled by |node|.
   layer->set_should_flatten_transform_from_property_tree(false);
 
@@ skipping 114 matching lines @@
 
 static inline bool HasCopyRequest(LayerImpl* layer) {
   return !layer->test_properties()->copy_requests.empty();
 }
 
 template <typename LayerType>
 bool ShouldCreateRenderSurface(LayerType* layer,
                                gfx::Transform current_transform,
                                bool axis_aligned) {
   const bool preserves_2d_axis_alignment =
-      (current_transform * layer->transform()).Preserves2dAxisAlignment() &&
+      (current_transform * Transform(layer)).Preserves2dAxisAlignment() &&
       axis_aligned && AnimationsPreserveAxisAlignment(layer);
   const bool is_root = !Parent(layer);
   if (is_root)
     return true;
 
   // If the layer uses a mask and the layer is not a replica layer.
   // TODO(weiliangc): After slimming paint there won't be replica layers.
   if (MaskLayer(layer) && ReplicaLayer(Parent(layer)) != layer) {
     return true;
   }
@@ skipping 125 matching lines @@
   bool requires_node = is_root || has_transparency ||
                        has_potential_opacity_animation || has_proxied_opacity ||
                        should_create_render_surface;
 
   int parent_id = data_from_ancestor.effect_tree_parent;
 
   if (!requires_node) {
     layer->SetEffectTreeIndex(parent_id);
     data_for_children->effect_tree_parent = parent_id;
     data_for_children->compound_transform_since_render_target *=
-        layer->transform();
+        Transform(layer);
     return false;
   }
 
   EffectNode node;
   node.owner_id = layer->id();
   if (AlwaysUseActiveTreeOpacity(layer)) {
     data_for_children->property_trees->always_use_active_tree_opacity_effect_ids
         .push_back(node.owner_id);
   }
 
@@ skipping 486 matching lines @@
     color = SkColorSetA(color, 255);
   BuildPropertyTreesTopLevelInternal(
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees, color);
   property_trees->ResetCachedData();
 }
 
 }  // namespace cc