cc :: Move some tracking of layer_property_changed to main thread.

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 286 matching lines @@
   if (requests->empty())
     return;
 
   bool was_empty = copy_requests_.empty();
   for (auto& request : *requests)
     copy_requests_.push_back(std::move(request));
   requests->clear();
 
   if (was_empty && layer_tree_impl()->IsActiveTree())
     layer_tree_impl()->AddLayerWithCopyOutputRequest(this);
-  NoteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::TakeCopyRequestsAndTransformToTarget(
     std::vector<scoped_ptr<CopyOutputRequest>>* requests) {
   DCHECK(!copy_requests_.empty());
   DCHECK(layer_tree_impl()->IsActiveTree());
   DCHECK_EQ(render_target(), this);
 
   size_t first_inserted_request = requests->size();
   for (auto& request : copy_requests_)
@@ skipping 315 matching lines @@
   layer->SetPositionConstraint(position_constraint_);
   layer->SetShouldFlattenTransform(should_flatten_transform_);
   layer->set_should_flatten_transform_from_property_tree(
       should_flatten_transform_from_property_tree_);
   layer->set_draw_blend_mode(draw_blend_mode_);
   layer->SetUseParentBackfaceVisibility(use_parent_backface_visibility_);
   layer->SetUseLocalTransformForBackfaceVisibility(
       use_local_transform_for_backface_visibility_);
   layer->SetShouldCheckBackfaceVisibility(should_check_backface_visibility_);
   layer->SetTransformAndInvertibility(transform_, transform_is_invertible_);
+  if (layer_property_changed_)
+    layer->NoteLayerPropertyChanged();
 
   layer->SetScrollClipLayer(scroll_clip_layer_id_);
   layer->SetElementId(element_id_);
   layer->SetMutableProperties(mutable_properties_);
   layer->set_user_scrollable_horizontal(user_scrollable_horizontal_);
   layer->set_user_scrollable_vertical(user_scrollable_vertical_);
 
   layer->SetScrollCompensationAdjustment(scroll_compensation_adjustment_);
 
   layer->PushScrollOffset(nullptr);
@@ skipping 60 matching lines @@
   layer->SetStackingOrderChanged(stacking_order_changed_);
   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;
   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 341 matching lines @@
     DCHECK_EQ(layer_tree_impl(), mask_layer->layer_tree_impl());
     DCHECK_NE(new_layer_id, mask_layer_id_);
   } else if (new_layer_id == mask_layer_id_) {
     return;
   }
 
   mask_layer_ = std::move(mask_layer);
   mask_layer_id_ = new_layer_id;
   if (mask_layer_)
     mask_layer_->SetParent(this);
-  NoteLayerPropertyChangedForSubtree();
 }
 
 scoped_ptr<LayerImpl> LayerImpl::TakeMaskLayer() {
   mask_layer_id_ = -1;
   return std::move(mask_layer_);
 }
 
 void LayerImpl::SetReplicaLayer(scoped_ptr<LayerImpl> replica_layer) {
   int new_layer_id = replica_layer ? replica_layer->id() : -1;
 
   if (replica_layer) {
     DCHECK_EQ(layer_tree_impl(), replica_layer->layer_tree_impl());
     DCHECK_NE(new_layer_id, replica_layer_id_);
   } else if (new_layer_id == replica_layer_id_) {
     return;
   }
 
   replica_layer_ = std::move(replica_layer);
   replica_layer_id_ = new_layer_id;
   if (replica_layer_)
     replica_layer_->SetParent(this);
-  NoteLayerPropertyChangedForSubtree();
 }
 
 scoped_ptr<LayerImpl> LayerImpl::TakeReplicaLayer() {
   replica_layer_id_ = -1;
   return std::move(replica_layer_);
 }
 
 ScrollbarLayerImplBase* LayerImpl::ToScrollbarLayer() {
   return nullptr;
 }
 
 void LayerImpl::SetDrawsContent(bool draws_content) {
   if (draws_content_ == draws_content)
     return;
 
   draws_content_ = draws_content;
   NoteLayerPropertyChanged();
 }
 
 void LayerImpl::SetHideLayerAndSubtree(bool hide) {
   if (hide_layer_and_subtree_ == hide)
     return;
 
   hide_layer_and_subtree_ = hide;
-  NoteLayerPropertyChangedForSubtree();
 }
 
 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) {
@@ skipping 67 matching lines @@
 
   background_filters_ = filters;
   NoteLayerPropertyChanged();
 }
 
 void LayerImpl::SetMasksToBounds(bool masks_to_bounds) {
   if (masks_to_bounds_ == masks_to_bounds)
     return;
 
   masks_to_bounds_ = masks_to_bounds;
-  NoteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::SetContentsOpaque(bool opaque) {
   if (contents_opaque_ == opaque)
     return;
 
   contents_opaque_ = opaque;
-  NoteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::SetOpacity(float opacity) {
   if (opacity_ == opacity)
     return;
 
   opacity_ = opacity;
   NoteLayerPropertyChangedForSubtree();
 }
 
@@ skipping 54 matching lines @@
   // If this layer is already in the element map, update its properties.
   layer_tree_impl_->AddToElementMap(this);
   SetNeedsPushProperties();
 }
 
 void LayerImpl::SetBlendMode(SkXfermode::Mode blend_mode) {
   if (blend_mode_ == blend_mode)
     return;
 
   blend_mode_ = blend_mode;
-  NoteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::SetIsRootForIsolatedGroup(bool root) {
   if (is_root_for_isolated_group_ == root)
     return;
 
   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;
-  NoteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::Set3dSortingContextId(int id) {
   if (id == sorting_context_id_)
     return;
   sorting_context_id_ = id;
-  NoteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::SetFrameTimingRequests(
     const std::vector<FrameTimingRequest>& requests) {
   frame_timing_requests_ = requests;
   frame_timing_requests_dirty_ = true;
   SetNeedsPushProperties();
 }
 
 void LayerImpl::GatherFrameTimingRequestIds(std::vector<int64_t>* request_ids) {
@@ skipping 251 matching lines @@
     if (pending_twin)
       pending_twin->DidUpdateScrollOffset();
   }
 }
 
 void LayerImpl::SetDoubleSided(bool double_sided) {
   if (double_sided_ == double_sided)
     return;
 
   double_sided_ = double_sided;
-  NoteLayerPropertyChangedForSubtree();
 }
 
 SimpleEnclosedRegion LayerImpl::VisibleOpaqueRegion() const {
   if (contents_opaque())
     return SimpleEnclosedRegion(visible_layer_rect());
   return SimpleEnclosedRegion();
 }
 
 void LayerImpl::DidBeginTracing() {}
 
@@ skipping 302 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