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;
+  bool requires_node =
+      is_root || has_transparency || has_potential_opacity_animation ||
+      has_potential_filter_animation || should_create_render_surface;

[jaydasika, 2016/07/20 20:53:06]

Is this condition required ? Doesn't has_potential_filter_animation =>
should_create_render_surface ?

[ajuma, 2016/07/21 16:42:18]

Done. (It's surprising that has_potential_opacity_animation doesn't also imply
should_create_render_surface.)

[jaydasika, 2016/07/21 17:22:35]

It sounds like a bug to me. For the case, current opacity is 1 and opacity is
animating we are not creating a render surface. I think we should. WDYT ?

[ajuma, 2016/07/21 18:49:41]

Yeah, it's a bug. I'll fix it in a separate CL.

It turns out that Blink happens to avoid hitting this bug since during opacity
animations, it changes opacity 1 to 1 - \epsilon. See
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/core/animation...
and
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/core/css/resol...

 
   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.filters = Filters(layer);

[weiliangc, 2016/07/21 01:06:38]

This would make a copy of the Filter owned by Layer/LayerImpl's test properties.
Would explicitly changing ownership be better? To avoid the case of changing
filter on layers when only using filters on effect node?

[ajuma, 2016/07/21 16:42:18]

If we transfer ownership rather than copying, we'll get stuck the next time we
need to rebuild property trees, since the old property trees (owning the filter)
will be gone, and the layer will no longer have a copy either.

   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