cc: Move filters to the effect tree

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 749 matching lines @@
 }
 
 static inline float Opacity(Layer* layer) {
   return layer->opacity();
 }
 
 static inline float Opacity(LayerImpl* layer) {
   return layer->test_properties()->opacity;
 }
 
+static inline const FilterOperations& Filters(Layer* layer) {
+  return layer->filters();
+}
+
+static inline const FilterOperations& Filters(LayerImpl* layer) {
+  return layer->test_properties()->filters;
+}
+
 static inline const FilterOperations& BackgroundFilters(Layer* layer) {
   return layer->background_filters();
 }
 
 static inline const FilterOperations& BackgroundFilters(LayerImpl* layer) {
   return layer->test_properties()->background_filters;
 }
 
 static inline bool HideLayerAndSubtree(Layer* layer) {
   return layer->hide_layer_and_subtree();
@@ skipping 35 matching lines @@
   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()) {
+  if (!Filters(layer).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 (HasPotentiallyRunningFilterAnimation(layer)) {
     return true;
   }
 
   int num_descendants_that_draw_content = NumDescendantsThatDrawContent(layer);
@@ skipping 85 matching lines @@
 
 template <typename LayerType>
 bool AddEffectNodeIfNeeded(
     const DataForRecursion<LayerType>& data_from_ancestor,
     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 has_potential_filter_animation =
+      HasPotentiallyRunningFilterAnimation(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 &=
       AnimationsPreserveAxisAlignment(layer);
 
   bool requires_node = is_root || has_transparency ||
                        has_potential_opacity_animation ||
                        should_create_render_surface;
 
@@ skipping 10 matching lines @@
   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.filters = Filters(layer);
   node.background_filters = BackgroundFilters(layer);
   node.has_potential_opacity_animation = has_potential_opacity_animation;
+  node.has_potential_filter_animation = has_potential_filter_animation;
   node.double_sided = DoubleSided(layer);
   node.subtree_hidden = HideLayerAndSubtree(layer);
   node.is_currently_animating_opacity = OpacityIsAnimating(layer);
+  node.is_currently_animating_filter = FilterIsAnimating(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