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

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 760 matching lines @@
   return result;
 }
 
 void LayerImpl::SetStackingOrderChanged(bool stacking_order_changed) {
   if (stacking_order_changed) {
     stacking_order_changed_ = true;
     NoteLayerPropertyChangedForSubtree();
   }
 }
 
+bool LayerImpl::LayerPropertyChanged() const {
+  if (layer_property_changed_)
+    return true;
+  TransformNode* node =
+      layer_tree_impl()->property_trees()->transform_tree.Node(
+          transform_tree_index());
+  if (node && node->data.transform_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)
@@ skipping 22 matching lines @@
     resource_provider->ValidateResource(resource_id);
 #endif
 }
 
 const char* LayerImpl::LayerTypeAsString() const {
   return "cc::LayerImpl";
 }
 
 void LayerImpl::ResetAllChangeTrackingForSubtree() {
   layer_property_changed_ = false;
+  if (TransformNode* transform_node =
+          layer_tree_impl_->property_trees()->transform_tree.Node(
+              transform_tree_index())) {
+    transform_node->data.transform_changed = false;
+  }
 
   update_rect_.SetRect(0, 0, 0, 0);
   damage_rect_.SetRect(0, 0, 0, 0);
 
   if (render_surface_)
     render_surface_->ResetPropertyChangedFlag();
 
   if (mask_layer_)
     mask_layer_->ResetAllChangeTrackingForSubtree();
 
@@ skipping 175 matching lines @@
 }
 
 void LayerImpl::SetBounds(const gfx::Size& bounds) {
   if (bounds_ == bounds)
     return;
 
   bounds_ = bounds;
 
   layer_tree_impl()->DidUpdateScrollState(id());
 
-  if (masks_to_bounds())
-    NoteLayerPropertyChangedForSubtree();
-  else
+  if (!masks_to_bounds())
     NoteLayerPropertyChanged();
 }
 
 void LayerImpl::SetBoundsDelta(const gfx::Vector2dF& bounds_delta) {
   DCHECK(IsActive());
   if (bounds_delta_ == bounds_delta)
     return;
 
   bounds_delta_ = bounds_delta;
 
@@ skipping 81 matching lines @@
   if (hide_layer_and_subtree_ == hide)
     return;
 
   hide_layer_and_subtree_ = hide;
 }
 
 void LayerImpl::SetTransformOrigin(const gfx::Point3F& transform_origin) {
   if (transform_origin_ == transform_origin)
     return;
   transform_origin_ = transform_origin;
-  NoteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::SetBackgroundColor(SkColor background_color) {
   if (background_color_ == background_color)
     return;
 
   background_color_ = background_color;
   NoteLayerPropertyChanged();
 }
 
@@ skipping 156 matching lines @@
 
   is_root_for_isolated_group_ = root;
   SetNeedsPushProperties();
 }
 
 void LayerImpl::SetPosition(const gfx::PointF& position) {
   if (position_ == position)
     return;
 
   position_ = position;
-  NoteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::SetShouldFlattenTransform(bool flatten) {
   if (should_flatten_transform_ == flatten)
     return;
 
   should_flatten_transform_ = flatten;
 }
 
 void LayerImpl::Set3dSortingContextId(int id) {
@@ skipping 561 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