cc: Move filters to the effect tree

cc/layers/layer_impl.cc

 // Copyright 2012 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/layers/layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 331 matching lines @@
   layer->background_color_ = background_color_;
   layer->safe_opaque_background_color_ = safe_opaque_background_color_;
   layer->blend_mode_ = blend_mode_;
   layer->draw_blend_mode_ = draw_blend_mode_;
   layer->position_ = position_;
   layer->transform_ = transform_;
   layer->transform_tree_index_ = transform_tree_index_;
   layer->effect_tree_index_ = effect_tree_index_;
   layer->clip_tree_index_ = clip_tree_index_;
   layer->scroll_tree_index_ = scroll_tree_index_;
-  layer->filters_ = filters_;
   layer->sorting_context_id_ = sorting_context_id_;
   layer->has_will_change_transform_hint_ = has_will_change_transform_hint_;
 
   if (layer_property_changed_) {
     layer->layer_tree_impl()->set_needs_update_draw_properties();
     layer->layer_property_changed_ = true;
   }
 
   // If whether layer has render surface changes, we need to update draw
   // properties.
@@ skipping 226 matching lines @@
     UpdatePropertyTreeTransformIsAnimated(
         HasPotentiallyRunningTransformAnimation());
   }
 }
 
 gfx::ScrollOffset LayerImpl::ScrollOffsetForAnimation() const {
   return CurrentScrollOffset();
 }
 
 void LayerImpl::OnFilterAnimated(const FilterOperations& filters) {
-  if (filters_ != filters) {
-    SetFilters(filters);
-    SetNeedsPushProperties();
-    layer_tree_impl()->set_needs_update_draw_properties();
-    EffectTree& effect_tree = layer_tree_impl()->property_trees()->effect_tree;
-    EffectNode* node = effect_tree.Node(effect_tree_index_);
-    DCHECK(layer_tree_impl()->property_trees()->IsInIdToIndexMap(
-        PropertyTrees::TreeType::EFFECT, id()));
-    node->effect_changed = true;
-    layer_tree_impl()->property_trees()->changed = true;
-    effect_tree.set_needs_update(true);
-  }
+  layer_tree_impl()->AddToFilterAnimationsMap(id(), filters);
+  PropertyTrees* property_trees = layer_tree_impl()->property_trees();
+  DCHECK(
+      property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::EFFECT, id()));
+  EffectNode* node = property_trees->effect_tree.Node(effect_tree_index());
+  if (node->filters == filters)
+    return;
+  node->filters = filters;
+  node->effect_changed = true;
+  property_trees->changed = true;
+  property_trees->effect_tree.set_needs_update(true);
+  SetNeedsPushProperties();
+  layer_tree_impl()->set_needs_update_draw_properties();
 }
 
 void LayerImpl::OnOpacityAnimated(float opacity) {
   UpdatePropertyTreeOpacity(opacity);
   SetNeedsPushProperties();
   layer_tree_impl()->set_needs_update_draw_properties();
   layer_tree_impl()->AddToOpacityAnimationsMap(id(), opacity);
 }
 
 void LayerImpl::OnTransformAnimated(const gfx::Transform& transform) {
@@ skipping 55 matching lines @@
   DCHECK(layer_tree_impl_);
   PropertyTrees* property_trees = layer_tree_impl()->property_trees();
   if (!property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::EFFECT, id()))
     return;
   EffectNode* node = property_trees->effect_tree.Node(
       property_trees->effect_id_to_index_map[id()]);
   node->has_potential_opacity_animation = has_potential_animation;
   property_trees->effect_tree.set_needs_update(true);
 }
 
+void LayerImpl::OnFilterIsCurrentlyAnimatingChanged(
+    bool is_currently_animating) {
+  DCHECK(layer_tree_impl_);
+  PropertyTrees* property_trees = layer_tree_impl()->property_trees();
+  if (!property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::EFFECT, id()))
+    return;
+  EffectNode* node = property_trees->effect_tree.Node(
+      property_trees->effect_id_to_index_map[id()]);
+
+  node->is_currently_animating_filter = is_currently_animating;
+}
+
+void LayerImpl::OnFilterIsPotentiallyAnimatingChanged(
+    bool has_potential_animation) {
+  DCHECK(layer_tree_impl_);
+  PropertyTrees* property_trees = layer_tree_impl()->property_trees();
+  if (!property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::EFFECT, id()))
+    return;
+  EffectNode* node = property_trees->effect_tree.Node(
+      property_trees->effect_id_to_index_map[id()]);
+  node->has_potential_filter_animation = has_potential_animation;
+}
+
 bool LayerImpl::IsActive() const {
   return layer_tree_impl_->IsActiveTree();
 }
 
 gfx::Size LayerImpl::bounds() const {
   gfx::Vector2d delta = gfx::ToCeiledVector2d(bounds_delta_);
   return gfx::Size(bounds_.width() + delta.x(),
                    bounds_.height() + delta.y());
 }
 
@@ skipping 73 matching lines @@
 
 SkColor LayerImpl::SafeOpaqueBackgroundColor() const {
   if (contents_opaque())
     return safe_opaque_background_color_;
   SkColor color = background_color();
   if (SkColorGetA(color) == 255)
     color = SK_ColorTRANSPARENT;
   return color;
 }
 
-void LayerImpl::SetFilters(const FilterOperations& filters) {
-  filters_ = filters;
-}
-
 bool LayerImpl::FilterIsAnimating() const {
   return GetAnimationHost()->IsAnimatingFilterProperty(
       element_id(), GetElementTypeForAnimation());
 }
 
 bool LayerImpl::HasPotentiallyRunningFilterAnimation() const {
   return GetAnimationHost()->HasPotentiallyRunningFilterAnimation(
       element_id(), GetElementTypeForAnimation());
 }
 
@@ skipping 401 matching lines @@
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       ScreenSpaceTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc