cc: Clean up Layer and LayerTreeHost.

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>
 
+#include "cc/animation/animation_host.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/trees/clip_node.h"
 #include "cc/trees/draw_property_utils.h"
 #include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/scroll_node.h"
@@ skipping 204 matching lines @@
 }
 
 static Layer* ReplicaLayer(Layer* layer) {
   return layer->replica_layer();
 }
 
 static LayerImpl* ReplicaLayer(LayerImpl* layer) {
   return layer->test_properties()->replica_layer;
 }
 
+// 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(
+      layer->element_id(), layer->GetElementTypeForAnimation());
+}
+
+template <typename LayerType>
+bool FilterIsAnimating(LayerType* layer) {
+  return layer->GetAnimationHost()->IsAnimatingFilterProperty(
+      layer->element_id(), layer->GetElementTypeForAnimation());
+}
+
+template <typename LayerType>
+bool HasPotentiallyRunningFilterAnimation(LayerType* layer) {
+  return layer->GetAnimationHost()->HasPotentiallyRunningFilterAnimation(
+      layer->element_id(), layer->GetElementTypeForAnimation());
+}
+
+template <typename LayerType>
+bool TransformIsAnimating(LayerType* layer) {
+  return layer->GetAnimationHost()->IsAnimatingTransformProperty(
+      layer->element_id(), layer->GetElementTypeForAnimation());
+}
+
+template <typename LayerType>
+bool HasPotentiallyRunningTransformAnimation(LayerType* layer) {
+  return layer->GetAnimationHost()->HasPotentiallyRunningTransformAnimation(
+      layer->element_id(), layer->GetElementTypeForAnimation());
+}
+
+template <typename LayerType>
+bool HasOnlyTranslationTransforms(LayerType* layer) {
+  return layer->GetAnimationHost()->HasOnlyTranslationTransforms(
+      layer->element_id(), layer->GetElementTypeForAnimation());
+}
+
+template <typename LayerType>
+bool AnimationsPreserveAxisAlignment(LayerType* layer) {
+  return layer->GetAnimationHost()->AnimationsPreserveAxisAlignment(
+      layer->element_id());
+}
+
+template <typename LayerType>
+bool HasAnyAnimationTargetingProperty(LayerType* layer,
+                                      TargetProperty::Type property) {
+  return layer->GetAnimationHost()->HasAnyAnimationTargetingProperty(
+      layer->element_id(), property);
+}
+
+// -------------------------------------------------------------------
+
 template <typename LayerType>
 static LayerType* GetTransformParent(const DataForRecursion<LayerType>& data,
                                      LayerType* layer) {
   return PositionConstraint(layer).is_fixed_position()
              ? data.transform_fixed_parent
              : data.transform_tree_parent;
 }
 
 template <typename LayerType>
 static ClipNode* GetClipParent(const DataForRecursion<LayerType>& data,
@@ skipping 177 matching lines @@
   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();
 
   const bool has_potentially_animated_transform =
-      layer->HasPotentiallyRunningTransformAnimation();
+      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 =
-      layer->HasAnyAnimationTargetingProperty(TargetProperty::TRANSFORM);
+      HasAnyAnimationTargetingProperty(layer, TargetProperty::TRANSFORM);
 
   const bool has_surface = created_render_surface;
 
   // A transform node is needed to change the render target for subtree when
   // a scroll child's render target is different from the scroll parent's render
   // target.
   const bool scroll_child_has_different_target =
       ScrollParent(layer) &&
       Parent(layer)->effect_tree_index() !=
           ScrollParent(layer)->effect_tree_index();
@@ skipping 100 matching lines @@
                     ->transform_id);
   data_for_children->property_trees->transform_tree.SetContentTargetId(
       node->id, data_for_children->property_trees->effect_tree
                     .Node(data_for_children->render_target)
                     ->transform_id);
   DCHECK_NE(
       data_for_children->property_trees->transform_tree.TargetId(node->id),
       kInvalidPropertyTreeNodeId);
 
   node->has_potential_animation = has_potentially_animated_transform;
-  node->is_currently_animating = layer->TransformIsAnimating();
+  node->is_currently_animating = TransformIsAnimating(layer);
   if (has_potentially_animated_transform) {
     node->has_only_translation_animations =
-        layer->HasOnlyTranslationTransforms();
+        HasOnlyTranslationTransforms(layer);
   }
 
   float post_local_scale_factor = 1.0f;
   if (is_root)
     post_local_scale_factor =
         data_for_children->property_trees->transform_tree.device_scale_factor();
 
   if (is_page_scale_layer) {
     post_local_scale_factor *= data_from_ancestor.page_scale_factor;
     data_for_children->property_trees->transform_tree.set_page_scale_factor(
@@ skipping 60 matching lines @@
   layer->set_should_flatten_transform_from_property_tree(false);
 
   data_for_children->scroll_snap += node->scroll_snap;
 
   node->owner_id = layer->id();
 
   return true;
 }
 
 static inline bool HasPotentialOpacityAnimation(Layer* layer) {
-  return layer->HasPotentiallyRunningOpacityAnimation() ||
+  return HasPotentiallyRunningOpacityAnimation(layer) ||
          layer->OpacityCanAnimateOnImplThread();
 }
 
 static inline bool HasPotentialOpacityAnimation(LayerImpl* layer) {
-  return layer->HasPotentiallyRunningOpacityAnimation() ||
+  return HasPotentiallyRunningOpacityAnimation(layer) ||
          layer->test_properties()->opacity_can_animate;
 }
 
 static inline bool DoubleSided(Layer* layer) {
   return layer->double_sided();
 }
 
 static inline bool DoubleSided(LayerImpl* layer) {
   return layer->test_properties()->double_sided;
 }
@@ skipping 77 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() &&
-      axis_aligned && layer->AnimationsPreserveAxisAlignment();
+      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;
   }
 
   // If the layer has a reflection.
   if (ReplicaLayer(layer)) {
     return true;
   }
 
   // If the layer uses a CSS filter.
   if (!layer->filters().IsEmpty() || !BackgroundFilters(layer).IsEmpty()) {
     return true;
   }
 
   // If the layer will use a CSS filter.  In this case, the animation
   // will start and add a filter to this layer, so it needs a surface.
-  if (layer->HasPotentiallyRunningFilterAnimation()) {
+  if (HasPotentiallyRunningFilterAnimation(layer)) {
     return true;
   }
 
   int num_descendants_that_draw_content = NumDescendantsThatDrawContent(layer);
 
   // If the layer flattens its subtree, but it is treated as a 3D object by its
   // parent (i.e. parent participates in a 3D rendering context).
   if (LayerIsInExisting3DRenderingContext(layer) &&
       ShouldFlattenTransform(layer) && num_descendants_that_draw_content > 0) {
     TRACE_EVENT_INSTANT0(
@@ skipping 83 matching lines @@
     LayerType* layer,
     DataForRecursion<LayerType>* data_for_children) {
   const bool is_root = !Parent(layer);
   const bool has_transparency = EffectiveOpacity(layer) != 1.f;
   const bool has_potential_opacity_animation =
       HasPotentialOpacityAnimation(layer);
   const bool should_create_render_surface = ShouldCreateRenderSurface(
       layer, data_from_ancestor.compound_transform_since_render_target,
       data_from_ancestor.axis_align_since_render_target);
   data_for_children->axis_align_since_render_target &=
-      layer->AnimationsPreserveAxisAlignment();
+      AnimationsPreserveAxisAlignment(layer);
 
   bool requires_node = is_root || has_transparency ||
                        has_potential_opacity_animation ||
                        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();
     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);
   }
 
   node.opacity = Opacity(layer);
   node.has_render_surface = should_create_render_surface;
   node.has_copy_request = HasCopyRequest(layer);
   node.background_filters = BackgroundFilters(layer);
   node.has_potential_opacity_animation = has_potential_opacity_animation;
   node.double_sided = DoubleSided(layer);
   node.subtree_hidden = HideLayerAndSubtree(layer);
-  node.is_currently_animating_opacity = layer->OpacityIsAnimating();
+  node.is_currently_animating_opacity = OpacityIsAnimating(layer);
 
   EffectTree& effect_tree = data_for_children->property_trees->effect_tree;
   if (MaskLayer(layer)) {
     node.mask_layer_id = MaskLayer(layer)->id();
     effect_tree.AddMaskOrReplicaLayerId(node.mask_layer_id);
   }
   if (ReplicaLayer(layer)) {
     node.replica_layer_id = ReplicaLayer(layer)->id();
     effect_tree.AddMaskOrReplicaLayerId(node.replica_layer_id);
     if (MaskLayer(ReplicaLayer(layer))) {
@@ skipping 463 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