cc : Delete LayerImpl::NoteLayerPropertyChangedForSubtree

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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/layer_tree_host_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1692 matching lines @@
   // are noted as they occur.
   // TODO(boliu): If we did a temporary software renderer frame, propogate the
   // damage forward to the next frame.
   for (size_t i = 0; i < frame->render_surface_layer_list->size(); i++) {
     (*frame->render_surface_layer_list)[i]->render_surface()->damage_tracker()->
         DidDrawDamagedArea();
   }
   active_tree_->root_layer()->ResetAllChangeTrackingForSubtree();
   active_tree_->property_trees()->transform_tree.ResetChangeTracking();
   active_tree_->property_trees()->effect_tree.ResetChangeTracking();
+  active_tree_->property_trees()->full_tree_damaged = false;
   active_tree_->property_trees()->changed = false;

[ajuma, 2016/03/02 14:34:10]

Would it make sense to add a method to PropertyTrees that does all this
reseting, so we don't need to duplicate this sequence of calls whenever we need
to reset?

[jaydasika, 2016/03/02 16:27:08]

Done.

 
   active_tree_->set_has_ever_been_drawn(true);
   devtools_instrumentation::DidDrawFrame(id_);
   benchmark_instrumentation::IssueImplThreadRenderingStatsEvent(
       rendering_stats_instrumentation_->impl_thread_rendering_stats());
   rendering_stats_instrumentation_->AccumulateAndClearImplThreadStats();
 }
 
 void LayerTreeHostImpl::DidDrawAllLayers(const FrameData& frame) {
   for (size_t i = 0; i < frame.will_draw_layers.size(); ++i)
@@ skipping 281 matching lines @@
             pending_tree_->property_trees());
       else
         active_tree_->root_layer()->PushLayerPropertyChangedForSubtree();
     }
     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()->full_tree_damaged = false;
       pending_tree_->property_trees()->changed = false;
     }
 
     // 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
     // next sync.
     DCHECK(!recycle_tree_);
     pending_tree_.swap(recycle_tree_);
 
     UpdateViewportContainerSizes();
@@ skipping 1966 matching lines @@
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc