cc: Move tracking of layer_property_changed to main thread (3)

cc/layers/layer.cc

 // Copyright 2010 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.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 273 matching lines @@
 void Layer::AddChild(scoped_refptr<Layer> child) {
   InsertChild(child, children_.size());
 }
 
 void Layer::InsertChild(scoped_refptr<Layer> child, size_t index) {
   DCHECK(IsPropertyChangeAllowed());
   child->RemoveFromParent();
   AddDrawableDescendants(child->NumDescendantsThatDrawContent() +
                          (child->DrawsContent() ? 1 : 0));
   child->SetParent(this);
   child->stacking_order_changed_ = true;

[ajuma, 2016/02/22 20:43:09]

Is Layer::stacking_order_changed_ unused now that it isn't being pushed?

+  child->SetSubtreePropertyChanged();
 
   index = std::min(index, children_.size());
   children_.insert(children_.begin() + index, child);
   SetNeedsFullTreeSync();
 }
 
 void Layer::RemoveFromParent() {
   DCHECK(IsPropertyChangeAllowed());
   if (parent_)
     parent_->RemoveChildOrDependent(this);
@@ skipping 372 matching lines @@
 
   inverse *= a;
   return inverse.Preserves2dAxisAlignment();
 }
 
 void Layer::SetTransform(const gfx::Transform& transform) {
   DCHECK(IsPropertyChangeAllowed());
   if (transform_ == transform)
     return;
 
+  SetSubtreePropertyChanged();
   if (layer_tree_host_) {
     if (TransformNode* transform_node =
             layer_tree_host_->property_trees()->transform_tree.Node(
                 transform_tree_index())) {
       if (transform_node->owner_id == id()) {
         // We need to trigger a rebuild if we could have affected 2d axis
         // alignment. We'll check to see if transform and transform_ are axis
         // align with respect to one another.
         bool invertible = false;
         bool preserves_2d_axis_alignment =
             Are2dAxisAligned(transform_, transform, &invertible);
         transform_node->data.local = transform;
         transform_node->data.needs_local_transform_update = true;
+        transform_node->data.transform_changed = true;
         layer_tree_host_->property_trees()->transform_tree.set_needs_update(
             true);
         if (preserves_2d_axis_alignment)
           SetNeedsCommitNoRebuild();
         else
           SetNeedsCommit();
         transform_ = transform;
         transform_is_invertible_ = invertible;
         return;
       }
@@ skipping 646 matching lines @@
     layer->PassCopyRequests(&main_thread_copy_requests);
   }
 
   // If the main thread commits multiple times before the impl thread actually
   // draws, then damage tracking will become incorrect if we simply clobber the
   // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e.
   // union) any update changes that have occurred on the main thread.
   update_rect_.Union(layer->update_rect());
   layer->SetUpdateRect(update_rect_);
 
-  layer->SetStackingOrderChanged(stacking_order_changed_);
-
   if (layer->layer_animation_controller() && layer_animation_controller_)
     layer_animation_controller_->PushAnimationUpdatesTo(
         layer->layer_animation_controller());
 
   if (frame_timing_requests_dirty_) {
     layer->SetFrameTimingRequests(frame_timing_requests_);
     frame_timing_requests_dirty_ = false;
   }
 
   // Reset any state that should be cleared for the next update.
@@ skipping 692 matching lines @@
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, -1);
   return ScreenSpaceTransformFromPropertyTrees(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc