cc : Delete LayerImpl::NoteLayerPropertyChangedForSubtree

This CL also :
  * tracks filter changes on main thread and filter
    animations on effect tree.
  * tracks scroll offset changes on transform tree.
  * tracks bounds delta changes on property trees.

BUG=584512

CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1752993002

Cr-Commit-Position: refs/heads/master@{#378824}

12 files changed, 159 insertions, 153 deletions

diff --git a/cc/layers/layer.cc b/cc/layers/layer.cc
index 3842741..24b57f9 100644
--- a/cc/layers/layer.cc
+++ b/cc/layers/layer.cc
@@ -500,6 +500,7 @@ void Layer::SetFilters(const FilterOperations& filters) {
   if (filters_ == filters)
     return;
   filters_ = filters;
+  SetSubtreePropertyChanged();
   SetNeedsCommit();
 }
 
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index 4b114294..41b1f11 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -708,7 +708,9 @@ base::DictionaryValue* LayerImpl::LayerTreeAsJson() const {
 }
 
 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;
@@ -722,7 +724,7 @@ bool LayerImpl::LayerPropertyChanged() const {
   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;
 }
@@ -733,27 +735,6 @@ void LayerImpl::NoteLayerPropertyChanged() {
   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();
@@ -770,7 +751,7 @@ void LayerImpl::PushLayerPropertyChangedForSubtree() {
   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);
@@ -917,7 +898,7 @@ void LayerImpl::UpdatePropertyTreeOpacity() {
     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);
   }
@@ -942,7 +923,17 @@ gfx::ScrollOffset LayerImpl::ScrollOffsetForAnimation() const {
 }
 
 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) {
@@ -1009,8 +1000,7 @@ void LayerImpl::SetBounds(const gfx::Size& bounds) {
 
   layer_tree_impl()->DidUpdateScrollState(id());
 
-  if (!masks_to_bounds())
-    NoteLayerPropertyChanged();
+  NoteLayerPropertyChanged();
 }
 
 void LayerImpl::SetBoundsDelta(const gfx::Vector2dF& bounds_delta) {
@@ -1039,8 +1029,8 @@ void LayerImpl::SetBoundsDelta(const gfx::Vector2dF& bounds_delta) {
           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();
   }
@@ -1145,7 +1135,6 @@ void LayerImpl::SetFilters(const FilterOperations& filters) {
     return;
 
   filters_ = filters;
-  NoteLayerPropertyChangedForSubtree();
 }
 
 bool LayerImpl::FilterIsAnimating() const {
@@ -1551,9 +1540,17 @@ 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()) {
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index fdc5261e..1a6e15c 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -709,11 +709,6 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
                              SkColor color,
                              float width) const;
 
-  void NoteLayerPropertyChangedForSubtree();
-
-  // Note carefully this does not affect the current layer.
-  void NoteLayerPropertyChangedForDescendants();
-
   gfx::Rect GetScaledEnclosingRectInTargetSpace(float scale) const;
 
  private:
diff --git a/cc/layers/layer_impl_unittest.cc b/cc/layers/layer_impl_unittest.cc
index ff553af..d30c504 100644
--- a/cc/layers/layer_impl_unittest.cc
+++ b/cc/layers/layer_impl_unittest.cc
@@ -26,20 +26,16 @@
 namespace cc {
 namespace {
 
-#define EXECUTE_AND_VERIFY_SUBTREE_CHANGED(code_to_test) \
-  root->ResetAllChangeTrackingForSubtree();              \
-  root->layer_tree_impl()                                \
-      ->property_trees()                                 \
-      ->transform_tree.ResetChangeTracking();            \
-  root->layer_tree_impl()                                \
-      ->property_trees()                                 \
-      ->effect_tree.ResetChangeTracking();               \
-  code_to_test;                                          \
-  EXPECT_TRUE(root->needs_push_properties());            \
-  EXPECT_FALSE(child->needs_push_properties());          \
-  EXPECT_FALSE(grand_child->needs_push_properties());    \
-  EXPECT_TRUE(root->LayerPropertyChanged());             \
-  EXPECT_TRUE(child->LayerPropertyChanged());            \
+#define EXECUTE_AND_VERIFY_SUBTREE_CHANGED(code_to_test)             \
+  root->ResetAllChangeTrackingForSubtree();                          \
+  root->layer_tree_impl()->property_trees()->ResetAllChangeTracking( \
+      PropertyTrees::ResetFlags::ALL_TREES);                         \
+  code_to_test;                                                      \
+  EXPECT_TRUE(root->needs_push_properties());                        \
+  EXPECT_FALSE(child->needs_push_properties());                      \
+  EXPECT_FALSE(grand_child->needs_push_properties());                \
+  EXPECT_TRUE(root->LayerPropertyChanged());                         \
+  EXPECT_TRUE(child->LayerPropertyChanged());                        \
   EXPECT_TRUE(grand_child->LayerPropertyChanged());
 
 #define EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(code_to_test)                \
@@ -63,14 +59,15 @@ namespace {
   EXPECT_FALSE(child->LayerPropertyChanged());                                 \
   EXPECT_FALSE(grand_child->LayerPropertyChanged());
 
-#define EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(code_to_test)                    \
-  root->ResetAllChangeTrackingForSubtree();                                    \
-  code_to_test;                                                                \
-  EXPECT_TRUE(root->needs_push_properties());                                  \
-  EXPECT_FALSE(child->needs_push_properties());                                \
-  EXPECT_FALSE(grand_child->needs_push_properties());                          \
-  EXPECT_TRUE(root->LayerPropertyChanged());                                   \
-  EXPECT_FALSE(child->LayerPropertyChanged());                                 \
+#define EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(code_to_test)             \
+  root->ResetAllChangeTrackingForSubtree();                             \
+  root->layer_tree_impl()->property_trees()->full_tree_damaged = false; \
+  code_to_test;                                                         \
+  EXPECT_TRUE(root->needs_push_properties());                           \
+  EXPECT_FALSE(child->needs_push_properties());                         \
+  EXPECT_FALSE(grand_child->needs_push_properties());                   \
+  EXPECT_TRUE(root->LayerPropertyChanged());                            \
+  EXPECT_FALSE(child->LayerPropertyChanged());                          \
   EXPECT_FALSE(grand_child->LayerPropertyChanged());
 
 #define VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(code_to_test)                \
@@ -168,8 +165,9 @@ TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) {
   host_impl.active_tree()->BuildPropertyTreesForTesting();
 
   // Changing these properties affects the entire subtree of layers.
-  EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(arbitrary_filters));
-  EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(FilterOperations()));
+  EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->OnFilterAnimated(arbitrary_filters));
+  EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
+      root->OnFilterAnimated(FilterOperations()));
   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->ScrollBy(arbitrary_vector2d));
   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetScrollDelta(gfx::Vector2d()));
   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->PushScrollOffsetFromMainThread(
@@ -177,6 +175,11 @@ TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) {
   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->OnOpacityAnimated(arbitrary_number));
   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
       root->OnTransformAnimated(arbitrary_transform));
+  // SetBoundsDelta changes subtree only when masks_to_bounds is true and it
+  // doesn't set needs_push_properties as it is always called on active tree.
+  root->SetMasksToBounds(true);
+  EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetBoundsDelta(arbitrary_vector2d);
+                                     root->SetNeedsPushProperties());
 
   // Changing these properties only affects the layer itself.
   EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetDrawsContent(true));
@@ -187,8 +190,9 @@ TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) {
 
   // Special case: check that SetBounds changes behavior depending on
   // masksToBounds.
+  gfx::Size bounds_size(135, 246);
   root->SetMasksToBounds(false);
-  EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetBounds(gfx::Size(135, 246)));
+  EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetBounds(bounds_size));
   host_impl.active_tree()->property_trees()->needs_rebuild = true;
   host_impl.active_tree()->BuildPropertyTreesForTesting();
 
@@ -241,7 +245,7 @@ TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) {
   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
       root->SetIsRootForIsolatedGroup(true));
   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetDrawsContent(true));
-  EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetBounds(arbitrary_size));
+  EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetBounds(bounds_size));
   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
       root->SetScrollParent(scroll_parent.get()));
   EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
@@ -311,10 +315,14 @@ TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) {
   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetForceRenderSurface(false));
 
   // Related filter functions.
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(arbitrary_filters));
-  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(arbitrary_filters));
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(FilterOperations()));
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(arbitrary_filters));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
+      root->OnFilterAnimated(arbitrary_filters));
+  VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
+      root->OnFilterAnimated(arbitrary_filters));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
+      root->OnFilterAnimated(FilterOperations()));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
+      root->OnFilterAnimated(arbitrary_filters));
 
   // Related scrolling functions.
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(large_size));
diff --git a/cc/layers/layer_unittest.cc b/cc/layers/layer_unittest.cc
index 7631e0f..0cb987a 100644
--- a/cc/layers/layer_unittest.cc
+++ b/cc/layers/layer_unittest.cc
@@ -1064,6 +1064,16 @@ TEST_F(LayerTest, LayerPropertyChangedForSubtree) {
       child2->PushPropertiesTo(child2_impl.get());
       grand_child->PushPropertiesTo(grand_child_impl.get()));
 
+  FilterOperations arbitrary_filters;
+  arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f));
+  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(1);
+  EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(arbitrary_filters));
+  EXECUTE_AND_VERIFY_SUBTREE_CHANGES_RESET(
+      root->PushPropertiesTo(root_impl.get());
+      child->PushPropertiesTo(child_impl.get());
+      child2->PushPropertiesTo(child2_impl.get());
+      grand_child->PushPropertiesTo(grand_child_impl.get()));
+
   gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f);
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(1);
   root->SetPosition(arbitrary_point_f);
@@ -1075,7 +1085,8 @@ TEST_F(LayerTest, LayerPropertyChangedForSubtree) {
       child->PushPropertiesTo(child_impl.get());
       child2->PushPropertiesTo(child2_impl.get());
       grand_child->PushPropertiesTo(grand_child_impl.get());
-      layer_tree_host_->property_trees()->transform_tree.ResetChangeTracking());
+      layer_tree_host_->property_trees()->ResetAllChangeTracking(
+          PropertyTrees::ResetFlags::ALL_TREES));
   EXPECT_FALSE(node->data.transform_changed);
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(1);
@@ -1093,7 +1104,8 @@ TEST_F(LayerTest, LayerPropertyChangedForSubtree) {
   EXECUTE_AND_VERIFY_SUBTREE_CHANGES_RESET(
       child->PushPropertiesTo(child_impl.get());
       grand_child->PushPropertiesTo(grand_child_impl.get());
-      layer_tree_host_->property_trees()->transform_tree.ResetChangeTracking());
+      layer_tree_host_->property_trees()->ResetAllChangeTracking(
+          PropertyTrees::ResetFlags::ALL_TREES));
   node = layer_tree_host_->property_trees()->transform_tree.Node(
       child->transform_tree_index());
   EXPECT_FALSE(node->data.transform_changed);
@@ -1109,7 +1121,8 @@ TEST_F(LayerTest, LayerPropertyChangedForSubtree) {
       child->PushPropertiesTo(child_impl.get());
       child2->PushPropertiesTo(child2_impl.get());
       grand_child->PushPropertiesTo(grand_child_impl.get());
-      layer_tree_host_->property_trees()->transform_tree.ResetChangeTracking());
+      layer_tree_host_->property_trees()->ResetAllChangeTracking(
+          PropertyTrees::ResetFlags::ALL_TREES));
 
   gfx::Transform arbitrary_transform;
   arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f);
@@ -1720,58 +1733,6 @@ TEST_F(LayerTest, PushPropertiesCausesLayerPropertyChangedForOpacity) {
   EXPECT_TRUE(impl_layer->LayerPropertyChanged());
 }
 
-TEST_F(LayerTest,
-       PushPropsDoesntCauseLayerPropertyChangedDuringImplOnlyFilterAnim) {
-  scoped_refptr<Layer> test_layer = Layer::Create(layer_settings_);
-  scoped_ptr<LayerImpl> impl_layer =
-      LayerImpl::Create(host_impl_.active_tree(), 1);
-
-  EXPECT_SET_NEEDS_FULL_TREE_SYNC(1,
-                                  layer_tree_host_->SetRootLayer(test_layer));
-
-  scoped_ptr<AnimationRegistrar> registrar;
-  if (settings().use_compositor_animation_timelines) {
-    AddAnimatedFilterToLayerWithPlayer(impl_layer->id(), timeline_impl(), 1.0,
-                                       1.f, 2.f);
-  } else {
-    registrar = AnimationRegistrar::Create();
-    impl_layer->layer_animation_controller()->SetAnimationRegistrar(
-        registrar.get());
-
-    AddAnimatedFilterToController(impl_layer->layer_animation_controller(), 1.0,
-                                  1.f, 2.f);
-  }
-
-  FilterOperations filters;
-  filters.Append(FilterOperation::CreateBlurFilter(2.f));
-  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetFilters(filters));
-
-  EXPECT_FALSE(impl_layer->LayerPropertyChanged());
-  test_layer->PushPropertiesTo(impl_layer.get());
-  EXPECT_TRUE(impl_layer->LayerPropertyChanged());
-
-  impl_layer->ResetAllChangeTrackingForSubtree();
-  if (settings().use_compositor_animation_timelines) {
-    int animation_id = AddAnimatedFilterToLayerWithPlayer(
-        impl_layer->id(), timeline_impl(), 1.0, 1.f, 2.f);
-    GetAnimationFromLayerWithExistingPlayer(impl_layer->id(), timeline_impl(),
-                                            animation_id)
-        ->set_is_impl_only(true);
-  } else {
-    AddAnimatedFilterToController(impl_layer->layer_animation_controller(), 1.0,
-                                  1.f, 2.f);
-    impl_layer->layer_animation_controller()
-        ->GetAnimation(TargetProperty::FILTER)
-        ->set_is_impl_only(true);
-  }
-  filters.Append(FilterOperation::CreateSepiaFilter(0.5f));
-  EXPECT_SET_NEEDS_COMMIT(1, test_layer->SetFilters(filters));
-
-  EXPECT_FALSE(impl_layer->LayerPropertyChanged());
-  test_layer->PushPropertiesTo(impl_layer.get());
-  EXPECT_FALSE(impl_layer->LayerPropertyChanged());
-}
-
 TEST_F(LayerTest, MaskAndReplicaHasParent) {
   scoped_refptr<Layer> parent = Layer::Create(layer_settings_);
   scoped_refptr<Layer> child = Layer::Create(layer_settings_);
diff --git a/cc/proto/property_tree.proto b/cc/proto/property_tree.proto
index 77f30f2..a91824c 100644
--- a/cc/proto/property_tree.proto
+++ b/cc/proto/property_tree.proto
@@ -91,7 +91,7 @@ message EffectNodeData {
   optional bool has_background_filters = 5;
   optional bool is_drawn = 6;
   optional bool has_animated_opacity = 7;
-  optional bool opacity_changed = 11;
+  optional bool effect_changed = 11;
   optional int64 num_copy_requests_in_subtree = 8;
   optional int64 transform_id = 9;
   optional int64 clip_id = 10;
@@ -174,7 +174,7 @@ message TransformTreeData {
 }
 
 // Proto for class PropertyTrees.
-// NEXT ID: 12
+// NEXT ID: 13
 message PropertyTrees {
   optional PropertyTree transform_tree = 1;
   optional PropertyTree effect_tree = 2;
@@ -184,6 +184,7 @@ message PropertyTrees {
   optional bool needs_rebuild = 4;
   optional bool non_root_surfaces_enabled = 5;
   optional bool changed = 11;
+  optional bool full_tree_damaged = 12;
   optional int64 sequence_number = 6;
 
   optional Vector2dF inner_viewport_container_bounds_delta = 8;
diff --git a/cc/trees/damage_tracker_unittest.cc b/cc/trees/damage_tracker_unittest.cc
index 452e79f..3b9d0af 100644
--- a/cc/trees/damage_tracker_unittest.cc
+++ b/cc/trees/damage_tracker_unittest.cc
@@ -77,9 +77,8 @@ void EmulateDrawingOneFrame(LayerImpl* root) {
   }
 
   root->ResetAllChangeTrackingForSubtree();
-  root->layer_tree_impl()
-      ->property_trees()
-      ->transform_tree.ResetChangeTracking();
+  root->layer_tree_impl()->property_trees()->ResetAllChangeTracking(
+      PropertyTrees::ResetFlags::ALL_TREES);
   root->layer_tree_impl()->property_trees()->effect_tree.ResetChangeTracking();
 }
 
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index c940d22..9ae961e 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -496,13 +496,16 @@ void LayerTreeHost::FinishCommitOnImplThread(LayerTreeHostImpl* host_impl) {
   sync_tree->UpdatePropertyTreeScrollingAndAnimationFromMainThread();
 
   micro_benchmark_controller_.ScheduleImplBenchmarks(host_impl);
-  property_trees_.transform_tree.ResetChangeTracking();
   // We don't track changes to effect tree on main thread. But, to preserve any
   // change tracking done on active tree's effect tree, we copy it to the main
   // thread's effect tree before we push the main thread property trees to
   // active tree.
   if (property_trees_changed_on_active_tree)
-    property_trees_.effect_tree.ResetChangeTracking();
+    property_trees_.ResetAllChangeTracking(
+        PropertyTrees::ResetFlags::ALL_TREES);
+  else
+    property_trees_.ResetAllChangeTracking(
+        PropertyTrees::ResetFlags::TRANSFORM_TREE);
 }
 
 void LayerTreeHost::WillCommit() {
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 16b7401..c70d87e 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -1684,9 +1684,8 @@ void LayerTreeHostImpl::DrawLayers(FrameData* frame) {
         DidDrawDamagedArea();
   }
   active_tree_->root_layer()->ResetAllChangeTrackingForSubtree();
-  active_tree_->property_trees()->transform_tree.ResetChangeTracking();
-  active_tree_->property_trees()->effect_tree.ResetChangeTracking();
-  active_tree_->property_trees()->changed = false;
+  active_tree_->property_trees()->ResetAllChangeTracking(
+      PropertyTrees::ResetFlags::ALL_TREES);
 
   active_tree_->set_has_ever_been_drawn(true);
   devtools_instrumentation::DidDrawFrame(id_);
@@ -1985,11 +1984,9 @@ void LayerTreeHostImpl::ActivateSyncTree() {
     TreeSynchronizer::PushProperties(pending_tree_->root_layer(),
                                      active_tree_->root_layer());
     pending_tree_->PushPropertiesTo(active_tree_.get());
-    if (pending_tree_->root_layer()) {
-      pending_tree_->property_trees()->transform_tree.ResetChangeTracking();
-      pending_tree_->property_trees()->effect_tree.ResetChangeTracking();
-      pending_tree_->property_trees()->changed = false;
-    }
+    if (pending_tree_->root_layer())
+      pending_tree_->property_trees()->ResetAllChangeTracking(
+          PropertyTrees::ResetFlags::ALL_TREES);
 
     // Now that we've synced everything from the pending tree to the active
     // tree, rename the pending tree the recycle tree so we can reuse it on the
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index 32cc2f0..a4fff25 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -699,6 +699,7 @@ class LayerTreeHostTestPropertyTreesChangedSync : public LayerTreeHostTest {
   enum Animations {
     OPACITY,
     TRANSFORM,
+    FILTER,
     END,
   };
 
@@ -709,6 +710,7 @@ class LayerTreeHostTestPropertyTreesChangedSync : public LayerTreeHostTest {
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     gfx::Transform transform;
+    FilterOperations filters;
     switch (static_cast<Animations>(index_)) {
       case OPACITY:
         index_++;
@@ -728,6 +730,18 @@ class LayerTreeHostTestPropertyTreesChangedSync : public LayerTreeHostTest {
         impl->active_tree()->root_layer()->OnTransformAnimated(transform);
         PostSetNeedsCommitToMainThread();
         break;
+      case FILTER:
+        index_++;
+        EXPECT_TRUE(impl->active_tree()->root_layer()->LayerPropertyChanged());
+        impl->active_tree()->root_layer()->ResetAllChangeTrackingForSubtree();
+        impl->active_tree()
+            ->property_trees()
+            ->transform_tree.ResetChangeTracking();
+        EXPECT_FALSE(impl->active_tree()->root_layer()->LayerPropertyChanged());
+        filters.Append(FilterOperation::CreateOpacityFilter(0.5f));
+        impl->active_tree()->root_layer()->OnFilterAnimated(filters);
+        PostSetNeedsCommitToMainThread();
+        break;
       case END:
         EXPECT_TRUE(impl->active_tree()->root_layer()->LayerPropertyChanged());
         EndTest();
diff --git a/cc/trees/property_tree.cc b/cc/trees/property_tree.cc
index a109832..12bba36 100644
--- a/cc/trees/property_tree.cc
+++ b/cc/trees/property_tree.cc
@@ -435,7 +435,7 @@ EffectNodeData::EffectNodeData()
       has_background_filters(false),
       is_drawn(true),
       has_animated_opacity(false),
-      opacity_changed(false),
+      effect_changed(false),
       num_copy_requests_in_subtree(0),
       transform_id(0),
       clip_id(0) {}
@@ -450,7 +450,7 @@ bool EffectNodeData::operator==(const EffectNodeData& other) const {
          has_background_filters == other.has_background_filters &&
          is_drawn == other.is_drawn &&
          has_animated_opacity == other.has_animated_opacity &&
-         opacity_changed == other.opacity_changed &&
+         effect_changed == other.effect_changed &&
          num_copy_requests_in_subtree == other.num_copy_requests_in_subtree &&
          transform_id == other.transform_id && clip_id == other.clip_id;
 }
@@ -465,7 +465,7 @@ void EffectNodeData::ToProtobuf(proto::TreeNode* proto) const {
   data->set_has_background_filters(has_background_filters);
   data->set_is_drawn(is_drawn);
   data->set_has_animated_opacity(has_animated_opacity);
-  data->set_opacity_changed(opacity_changed);
+  data->set_effect_changed(effect_changed);
   data->set_num_copy_requests_in_subtree(num_copy_requests_in_subtree);
   data->set_transform_id(transform_id);
   data->set_clip_id(clip_id);
@@ -482,7 +482,7 @@ void EffectNodeData::FromProtobuf(const proto::TreeNode& proto) {
   has_background_filters = data.has_background_filters();
   is_drawn = data.is_drawn();
   has_animated_opacity = data.has_animated_opacity();
-  opacity_changed = data.opacity_changed();
+  effect_changed = data.effect_changed();
   num_copy_requests_in_subtree = data.num_copy_requests_in_subtree();
   transform_id = data.transform_id();
   clip_id = data.clip_id();
@@ -1178,10 +1178,10 @@ void EffectTree::UpdateIsDrawn(EffectNode* node, EffectNode* parent_node) {
     node->data.is_drawn = true;
 }
 
-void EffectTree::UpdateOpacityChanged(EffectNode* node,
-                                      EffectNode* parent_node) {
-  if (parent_node && parent_node->data.opacity_changed) {
-    node->data.opacity_changed = true;
+void EffectTree::UpdateEffectChanged(EffectNode* node,
+                                     EffectNode* parent_node) {
+  if (parent_node && parent_node->data.effect_changed) {
+    node->data.effect_changed = true;
   }
 }
 
@@ -1191,7 +1191,7 @@ void EffectTree::UpdateEffects(int id) {
 
   UpdateOpacities(node, parent_node);
   UpdateIsDrawn(node, parent_node);
-  UpdateOpacityChanged(node, parent_node);
+  UpdateEffectChanged(node, parent_node);
 }
 
 void EffectTree::ClearCopyRequests() {
@@ -1220,7 +1220,7 @@ bool EffectTree::ContributesToDrawnSurface(int id) {
 void EffectTree::ResetChangeTracking() {
   for (int id = 1; id < static_cast<int>(size()); ++id) {
     EffectNode* node = Node(id);
-    node->data.opacity_changed = false;
+    node->data.effect_changed = false;
   }
 }
 
@@ -1403,6 +1403,7 @@ PropertyTrees::PropertyTrees()
     : needs_rebuild(true),
       non_root_surfaces_enabled(true),
       changed(false),
+      full_tree_damaged(false),
       sequence_number(0) {
   transform_tree.SetPropertyTrees(this);
   effect_tree.SetPropertyTrees(this);
@@ -1417,6 +1418,7 @@ bool PropertyTrees::operator==(const PropertyTrees& other) const {
          effect_tree == other.effect_tree && clip_tree == other.clip_tree &&
          scroll_tree == other.scroll_tree &&
          needs_rebuild == other.needs_rebuild && changed == other.changed &&
+         full_tree_damaged == other.full_tree_damaged &&
          non_root_surfaces_enabled == other.non_root_surfaces_enabled &&
          sequence_number == other.sequence_number;
 }
@@ -1428,6 +1430,7 @@ PropertyTrees& PropertyTrees::operator=(const PropertyTrees& from) {
   scroll_tree = from.scroll_tree;
   needs_rebuild = from.needs_rebuild;
   changed = from.changed;
+  full_tree_damaged = from.full_tree_damaged;
   non_root_surfaces_enabled = from.non_root_surfaces_enabled;
   sequence_number = from.sequence_number;
   inner_viewport_container_bounds_delta_ =
@@ -1452,6 +1455,7 @@ void PropertyTrees::ToProtobuf(proto::PropertyTrees* proto) const {
   scroll_tree.ToProtobuf(proto->mutable_scroll_tree());
   proto->set_needs_rebuild(needs_rebuild);
   proto->set_changed(changed);
+  proto->set_full_tree_damaged(full_tree_damaged);
   proto->set_non_root_surfaces_enabled(non_root_surfaces_enabled);
 
   // TODO(khushalsagar): Consider using the sequence number to decide if
@@ -1468,6 +1472,7 @@ void PropertyTrees::FromProtobuf(const proto::PropertyTrees& proto) {
 
   needs_rebuild = proto.needs_rebuild();
   changed = proto.changed();
+  full_tree_damaged = proto.full_tree_damaged();
   non_root_surfaces_enabled = proto.non_root_surfaces_enabled();
   sequence_number = proto.sequence_number();
 
@@ -1503,9 +1508,9 @@ void PropertyTrees::SetInnerViewportScrollBoundsDelta(
 void PropertyTrees::PushChangeTrackingTo(PropertyTrees* tree) {
   for (int id = 1; id < static_cast<int>(effect_tree.size()); ++id) {
     EffectNode* node = effect_tree.Node(id);
-    if (node->data.opacity_changed) {
+    if (node->data.effect_changed) {
       EffectNode* target_node = tree->effect_tree.Node(node->id);
-      target_node->data.opacity_changed = true;
+      target_node->data.effect_changed = true;
     }
   }
   for (int id = 1; id < static_cast<int>(transform_tree.size()); ++id) {
@@ -1515,6 +1520,23 @@ void PropertyTrees::PushChangeTrackingTo(PropertyTrees* tree) {
       target_node->data.transform_changed = true;
     }
   }
+  tree->full_tree_damaged = full_tree_damaged;
+}
+
+void PropertyTrees::ResetAllChangeTracking(ResetFlags flag) {
+  switch (flag) {
+    case EFFECT_TREE:
+      effect_tree.ResetChangeTracking();
+      break;
+    case TRANSFORM_TREE:
+      transform_tree.ResetChangeTracking();
+      break;
+    case ALL_TREES:
+      transform_tree.ResetChangeTracking();
+      effect_tree.ResetChangeTracking();
+  }
+  changed = false;
+  full_tree_damaged = false;
 }
 
 }  // namespace cc
diff --git a/cc/trees/property_tree.h b/cc/trees/property_tree.h
index a9f160e..625bbc4 100644
--- a/cc/trees/property_tree.h
+++ b/cc/trees/property_tree.h
@@ -258,9 +258,9 @@ struct CC_EXPORT EffectNodeData {
   bool has_background_filters;
   bool is_drawn;
   bool has_animated_opacity;
-  // We need to track changes to opacity on the compositor to compute damage
+  // We need to track changes to effects on the compositor to compute damage
   // rect.
-  bool opacity_changed;
+  bool effect_changed;
   int num_copy_requests_in_subtree;
   int transform_id;
   int clip_id;
@@ -528,7 +528,7 @@ class CC_EXPORT EffectTree final : public PropertyTree<EffectNode> {
 
   void UpdateEffects(int id);
 
-  void UpdateOpacityChanged(EffectNode* node, EffectNode* parent_node);
+  void UpdateEffectChanged(EffectNode* node, EffectNode* parent_node);
 
   void ClearCopyRequests();
 
@@ -587,12 +587,20 @@ class CC_EXPORT PropertyTrees final {
   // we did any change tracking so that we can skip copying the change status
   // between property trees when this bool is false.
   bool changed;
+  // We cache a global bool for full tree damages to avoid walking the entire
+  // tree.
+  // TODO(jaydasika): Changes to transform and effects that damage the entire
+  // tree should be tracked by this bool. Currently, they are tracked by the
+  // individual nodes.
+  bool full_tree_damaged;
   int sequence_number;
+  enum ResetFlags { EFFECT_TREE, TRANSFORM_TREE, ALL_TREES };
 
   void SetInnerViewportContainerBoundsDelta(gfx::Vector2dF bounds_delta);
   void SetOuterViewportContainerBoundsDelta(gfx::Vector2dF bounds_delta);
   void SetInnerViewportScrollBoundsDelta(gfx::Vector2dF bounds_delta);
   void PushChangeTrackingTo(PropertyTrees* tree);
+  void ResetAllChangeTracking(ResetFlags flag);
 
   gfx::Vector2dF inner_viewport_container_bounds_delta() const {
     return inner_viewport_container_bounds_delta_;