cc : Delete LayerImpl::NoteLayerPropertyChangedForSubtree

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 <utility>
@@ skipping 688 matching lines @@
 
   list = new base::ListValue;
   for (size_t i = 0; i < children_.size(); ++i)
     list->Append(children_[i]->LayerTreeAsJson());
   result->Set("Children", list);
 
   return result;
 }
 
 bool LayerImpl::LayerPropertyChanged() const {
-  if (layer_property_changed_)
+  if (layer_property_changed_ ||
+      (layer_tree_impl()->property_trees() &&
+       layer_tree_impl()->property_trees()->full_tree_damaged))
     return true;
   if (transform_tree_index() == -1)
     return false;
   TransformNode* transform_node =
       layer_tree_impl()->property_trees()->transform_tree.Node(
           transform_tree_index());
   if (transform_node && transform_node->data.transform_changed)
     return true;
   if (effect_tree_index() == -1)
     return false;
   EffectNode* effect_node =
       layer_tree_impl()->property_trees()->effect_tree.Node(
           effect_tree_index());
-  if (effect_node && effect_node->data.opacity_changed)
+  if (effect_node && effect_node->data.effect_changed)
     return true;
   return false;
 }
 
 void LayerImpl::NoteLayerPropertyChanged() {
   layer_property_changed_ = true;
   layer_tree_impl()->set_needs_update_draw_properties();
   SetNeedsPushProperties();
 }
 
-void LayerImpl::NoteLayerPropertyChangedForSubtree() {
-  layer_property_changed_ = true;
-  layer_tree_impl()->set_needs_update_draw_properties();
-  for (size_t i = 0; i < children_.size(); ++i)
-    children_[i]->NoteLayerPropertyChangedForDescendantsInternal();
-  SetNeedsPushProperties();
-}
-
-void LayerImpl::NoteLayerPropertyChangedForDescendantsInternal() {
-  layer_property_changed_ = true;
-  for (size_t i = 0; i < children_.size(); ++i)
-    children_[i]->NoteLayerPropertyChangedForDescendantsInternal();
-}
-
-void LayerImpl::NoteLayerPropertyChangedForDescendants() {
-  layer_tree_impl()->set_needs_update_draw_properties();
-  for (size_t i = 0; i < children_.size(); ++i)
-    children_[i]->NoteLayerPropertyChangedForDescendantsInternal();
-  SetNeedsPushProperties();
-}
-
 void LayerImpl::PushLayerPropertyChangedForSubtreeInternal() {
   if (LayerPropertyChanged())
     NoteLayerPropertyChanged();
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->PushLayerPropertyChangedForSubtreeInternal();
 }
 
 void LayerImpl::PushLayerPropertyChangedForSubtree() {
   // We need to update property trees first as layer property can change
   // when its corresponsing property tree node changes.
   PropertyTrees* property_trees = layer_tree_impl()->property_trees();
   EffectTree effect_tree = property_trees->effect_tree;
   TransformTree transform_tree = property_trees->transform_tree;
   for (int i = 1; i < static_cast<int>(effect_tree.size()); ++i) {
     EffectNode* node = effect_tree.Node(i);
     EffectNode* parent_node = effect_tree.parent(node);
-    effect_tree.UpdateOpacityChanged(node, parent_node);
+    effect_tree.UpdateEffectChanged(node, parent_node);
   }
   for (int i = 1; i < static_cast<int>(transform_tree.size()); ++i) {
     TransformNode* node = transform_tree.Node(i);
     TransformNode* parent_node = transform_tree.parent(node);
     TransformNode* source_node = transform_tree.Node(node->data.source_node_id);
     transform_tree.UpdateTransformChanged(node, parent_node, source_node);
   }
   PushLayerPropertyChangedForSubtreeInternal();
 }
 
@@ skipping 126 matching lines @@
     EffectNode* node = effect_tree.Node(effect_tree_index_);
     // A LayerImpl's own current state is insufficient for determining whether
     // it owns an OpacityNode, since this depends on the state of the
     // corresponding Layer at the time of the last commit. For example, an
     // opacity animation might have been in progress at the time the last commit
     // started, but might have finished since then on the compositor thread.
     float effective_opacity = EffectiveOpacity();
     if (node->owner_id != id() || node->data.opacity == effective_opacity)
       return;
     node->data.opacity = effective_opacity;
-    node->data.opacity_changed = true;
+    node->data.effect_changed = true;
     layer_tree_impl()->property_trees()->changed = true;
     effect_tree.set_needs_update(true);
   }
 }
 
 void LayerImpl::UpdatePropertyTreeForScrollingAndAnimationIfNeeded() {
   if (scrollable())
     UpdatePropertyTreeScrollOffset();
 
   if (HasAnyAnimationTargetingProperty(TargetProperty::OPACITY))
     UpdatePropertyTreeOpacity();
 
   if (HasAnyAnimationTargetingProperty(TargetProperty::TRANSFORM)) {
     UpdatePropertyTreeTransform();
     UpdatePropertyTreeTransformIsAnimated(
         HasPotentiallyRunningTransformAnimation());
   }
 }
 
 gfx::ScrollOffset LayerImpl::ScrollOffsetForAnimation() const {
   return CurrentScrollOffset();
 }
 
 void LayerImpl::OnFilterAnimated(const FilterOperations& filters) {
-  SetFilters(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_EQ(node->owner_id, id());
+    node->data.effect_changed = true;
+    layer_tree_impl()->property_trees()->changed = true;
+    effect_tree.set_needs_update(true);
+  }
 }
 
 void LayerImpl::OnOpacityAnimated(float opacity) {
   SetOpacity(opacity);
   // When hide_layer_and_subtree is true, the effective opacity is zero and we
   // need not update the opacity on property trees.
   if (!hide_layer_and_subtree_) {
     UpdatePropertyTreeOpacity();
     SetNeedsPushProperties();
     layer_tree_impl()->set_needs_update_draw_properties();
@@ skipping 76 matching lines @@
 
   if (masks_to_bounds()) {
     // If layer is clipping, then update the clip node using the new bounds.
     ClipNode* clip_node = property_trees->clip_tree.Node(clip_tree_index());
     if (clip_node) {
       DCHECK(id() == clip_node->owner_id);
       clip_node->data.clip = gfx::RectF(
           gfx::PointF() + offset_to_transform_parent(), gfx::SizeF(bounds()));
       property_trees->clip_tree.set_needs_update(true);
     }
-
-    NoteLayerPropertyChangedForSubtree();
+    property_trees->full_tree_damaged = true;
+    layer_tree_impl()->set_needs_update_draw_properties();
   } else {
     NoteLayerPropertyChanged();
   }
 }
 
 void LayerImpl::SetMaskLayer(scoped_ptr<LayerImpl> mask_layer) {
   int new_layer_id = mask_layer ? mask_layer->id() : -1;
 
   if (mask_layer) {
     DCHECK_EQ(layer_tree_impl(), mask_layer->layer_tree_impl());
@@ skipping 84 matching lines @@
       color = SkColorSetA(color, 255);
   }
   return color;
 }
 
 void LayerImpl::SetFilters(const FilterOperations& filters) {
   if (filters_ == filters)
     return;
 
   filters_ = filters;
-  NoteLayerPropertyChangedForSubtree();
 }
 
 bool LayerImpl::FilterIsAnimating() const {
   LayerAnimationController::ObserverType observer_type =
       IsActive() ? LayerAnimationController::ObserverType::ACTIVE
                  : LayerAnimationController::ObserverType::PENDING;
   return layer_animation_controller_
              ? layer_animation_controller_->IsCurrentlyAnimatingProperty(
                    TargetProperty::FILTER, observer_type)
              : layer_tree_impl_->IsAnimatingFilterProperty(this);
@@ skipping 385 matching lines @@
       node->data.needs_local_transform_update = true;
       transform_tree.set_needs_update(true);
     }
   }
 }
 
 void LayerImpl::DidUpdateScrollOffset() {
   DCHECK(scroll_offset_);
 
   layer_tree_impl()->DidUpdateScrollState(id());
-  NoteLayerPropertyChangedForSubtree();
 
-  UpdatePropertyTreeScrollOffset();
+  if (transform_tree_index_ != -1) {
+    UpdatePropertyTreeScrollOffset();
+    TransformTree& transform_tree =
+        layer_tree_impl()->property_trees()->transform_tree;
+    TransformNode* node = transform_tree.Node(transform_tree_index_);
+    node->data.transform_changed = true;
+    layer_tree_impl()->property_trees()->changed = true;
+    layer_tree_impl()->set_needs_update_draw_properties();
+    SetNeedsPushProperties();
+  }
 
   // Inform the pending twin that a property changed.
   if (layer_tree_impl()->IsActiveTree()) {
     LayerImpl* pending_twin = layer_list_impl_->FindPendingLayerById(id());
     if (pending_twin)
       pending_twin->DidUpdateScrollOffset();
   }
 }
 
 void LayerImpl::SetDoubleSided(bool double_sided) {
@@ skipping 279 matching lines @@
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       DrawTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc