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 688 matching lines @@
   layer->SetDebugInfo(debug_info_);
 
   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.
   stacking_order_changed_ = false;
   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;

[ajuma, 2016/02/12 23:57:03]

Same comment as in Layer::PushProperties.

[jaydasika, 2016/02/16 22:30:36]

Done.

+  }
   update_rect_ = gfx::Rect();
   needs_push_properties_ = false;
   num_dependents_need_push_properties_ = 0;
 }
 
 bool LayerImpl::IsAffectedByPageScale() const {
   TransformTree& transform_tree =
       layer_tree_impl()->property_trees()->transform_tree;
   return transform_tree.Node(transform_tree_index())
       ->data.in_subtree_of_page_scale_layer;
@@ skipping 52 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;

[ajuma, 2016/02/12 23:57:03]

An alternative to doing this layer-by-layer would be to clear this on the entire
transform tree at the same time (and call this in LayerTreeHostImpl::DrawLayers,
at the same place where we call RestAllChangeTrackingForSubtree on the root).

[jaydasika, 2016/02/16 22:30:36]

Done.

+  }
 
   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();

[ajuma, 2016/02/12 23:57:03]

Is this still needed? LayerImpl::SetBounds should (outside of tests) only get
called during PushProperties, in which case we've already accounted for the
change on the other tree.

[jaydasika, 2016/02/16 22:30:36]

In Layer, we set SubtreePropertyChanged to true only when mask_to_bounds is
true. So, we need to handle the other case here. (And we can't to do this on
Layer because Layer currently supports changing entire subtree, not individual
layers). 

[ajuma, 2016/02/16 22:55:50]

Ah, makes sense. Please add a comment about this (or just remove the 'if' and
call NoteLayerPropertyChanged unconditionally).

[jaydasika, 2016/02/17 02:00:15]

Forgot adding a comment here, will add it in the next CL.

 }
 
 void LayerImpl::SetBoundsDelta(const gfx::Vector2dF& bounds_delta) {
   DCHECK(IsActive());
   if (bounds_delta_ == bounds_delta)
     return;
 
   bounds_delta_ = bounds_delta;
 
   PropertyTrees* property_trees = layer_tree_impl()->property_trees();
@@ skipping 80 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