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

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 70 matching lines @@
       masks_to_bounds_(false),
       contents_opaque_(false),
       double_sided_(true),
       should_flatten_transform_(true),
       use_parent_backface_visibility_(false),
       use_local_transform_for_backface_visibility_(false),
       should_check_backface_visibility_(false),
       force_render_surface_(false),
       transform_is_invertible_(true),
       has_render_surface_(false),
+      subtree_property_changed_(false),
       background_color_(0),
       opacity_(1.f),
       blend_mode_(SkXfermode::kSrcOver_Mode),
       draw_blend_mode_(SkXfermode::kSrcOver_Mode),
       scroll_parent_(nullptr),
       layer_or_descendant_is_drawn_tracker_(0),
       sorted_for_recursion_tracker_(0),
       visited_tracker_(0),
       clip_parent_(nullptr),
       replica_layer_(nullptr),
@@ skipping 316 matching lines @@
     auto it = std::find_if(copy_requests_.begin(), copy_requests_.end(),
                            [source](const scoped_ptr<CopyOutputRequest>& x) {
                              return x->source() == source;
                            });
     if (it != copy_requests_.end())
       copy_requests_.erase(it);
   }
   if (request->IsEmpty())
     return;
   copy_requests_.push_back(std::move(request));
+  SetSubtreePropertyChanged();
   SetNeedsCommit();
 }
 
 void Layer::SetBackgroundColor(SkColor background_color) {
   DCHECK(IsPropertyChangeAllowed());
   if (background_color_ == background_color)
     return;
   background_color_ = background_color;
   SetNeedsCommit();
 }
@@ skipping 16 matching lines @@
   }
   return color;
 }
 
 void Layer::SetMasksToBounds(bool masks_to_bounds) {
   DCHECK(IsPropertyChangeAllowed());
   if (masks_to_bounds_ == masks_to_bounds)
     return;
   masks_to_bounds_ = masks_to_bounds;
   SetNeedsCommit();
+  SetSubtreePropertyChanged();
 }
 
 void Layer::SetMaskLayer(Layer* mask_layer) {
   DCHECK(IsPropertyChangeAllowed());
   if (mask_layer_.get() == mask_layer)
     return;
   if (mask_layer_.get()) {
     DCHECK_EQ(this, mask_layer_->parent());
     mask_layer_->RemoveFromParent();
   }
   mask_layer_ = mask_layer;
   if (mask_layer_.get()) {
     DCHECK(!mask_layer_->parent());
     mask_layer_->RemoveFromParent();
     mask_layer_->SetParent(this);
     mask_layer_->SetIsMask(true);
   }
+  SetSubtreePropertyChanged();
   SetNeedsFullTreeSync();
 }
 
 void Layer::SetReplicaLayer(Layer* layer) {
   DCHECK(IsPropertyChangeAllowed());
   if (replica_layer_.get() == layer)
     return;
   if (replica_layer_.get()) {
     DCHECK_EQ(this, replica_layer_->parent());
     replica_layer_->RemoveFromParent();
   }
   replica_layer_ = layer;
   if (replica_layer_.get()) {
     DCHECK(!replica_layer_->parent());
     replica_layer_->RemoveFromParent();
     replica_layer_->SetParent(this);
   }
+  SetSubtreePropertyChanged();
   SetNeedsFullTreeSync();
 }
 
 void Layer::SetFilters(const FilterOperations& filters) {
   DCHECK(IsPropertyChangeAllowed());
   if (filters_ == filters)
     return;
   filters_ = filters;
   SetNeedsCommit();
 }
@@ skipping 96 matching lines @@
     case SkXfermode::kPlus_Mode:
     case SkXfermode::kModulate_Mode:
       // Porter Duff Compositing Operators are not yet supported
       // http://dev.w3.org/fxtf/compositing-1/#porterduffcompositingoperators
       NOTREACHED();
       return;
   }
 
   blend_mode_ = blend_mode;
   SetNeedsCommit();
+  SetSubtreePropertyChanged();
 }
 
 void Layer::SetIsRootForIsolatedGroup(bool root) {
   DCHECK(IsPropertyChangeAllowed());
   if (is_root_for_isolated_group_ == root)
     return;
   is_root_for_isolated_group_ = root;
   SetNeedsCommit();
 }
 
 void Layer::SetContentsOpaque(bool opaque) {
   DCHECK(IsPropertyChangeAllowed());
   if (contents_opaque_ == opaque)
     return;
   contents_opaque_ = opaque;
   SetNeedsCommit();
+  SetSubtreePropertyChanged();
 }
 
 void Layer::SetPosition(const gfx::PointF& position) {
   DCHECK(IsPropertyChangeAllowed());
   if (position_ == position)
     return;
   position_ = position;
 
   if (!layer_tree_host_)
     return;
@@ skipping 356 matching lines @@
   force_render_surface_ = force;
   SetNeedsCommit();
 }
 
 void Layer::SetDoubleSided(bool double_sided) {
   DCHECK(IsPropertyChangeAllowed());
   if (double_sided_ == double_sided)
     return;
   double_sided_ = double_sided;
   SetNeedsCommit();
+  SetSubtreePropertyChanged();
 }
 
 void Layer::Set3dSortingContextId(int id) {
   DCHECK(IsPropertyChangeAllowed());
   if (id == sorting_context_id_)
     return;
   sorting_context_id_ = id;
   SetNeedsCommit();
+  SetSubtreePropertyChanged();
 }
 
 void Layer::SetTransformTreeIndex(int index) {
   DCHECK(IsPropertyChangeAllowed());
   if (transform_tree_index_ == index)
     return;
   transform_tree_index_ = index;
   SetNeedsPushProperties();
 }
 
@@ skipping 63 matching lines @@
   SetClipTreeIndex(invalid_property_tree_index);
   SetEffectTreeIndex(invalid_property_tree_index);
 }
 
 void Layer::SetShouldFlattenTransform(bool should_flatten) {
   DCHECK(IsPropertyChangeAllowed());
   if (should_flatten_transform_ == should_flatten)
     return;
   should_flatten_transform_ = should_flatten;
   SetNeedsCommit();
+  SetSubtreePropertyChanged();
 }
 
 void Layer::SetUseParentBackfaceVisibility(bool use) {
   DCHECK(IsPropertyChangeAllowed());
   if (use_parent_backface_visibility_ == use)
     return;
   use_parent_backface_visibility_ = use;
   SetNeedsPushProperties();
 }
 
@@ skipping 21 matching lines @@
   UpdateDrawsContent(HasDrawableContent());
 }
 
 void Layer::SetHideLayerAndSubtree(bool hide) {
   DCHECK(IsPropertyChangeAllowed());
   if (hide_layer_and_subtree_ == hide)
     return;
 
   hide_layer_and_subtree_ = hide;
   SetNeedsCommit();
+  SetSubtreePropertyChanged();
 }
 
 void Layer::SetNeedsDisplayRect(const gfx::Rect& dirty_rect) {
   if (dirty_rect.IsEmpty())
     return;
 
   SetNeedsPushProperties();
   update_rect_.Union(dirty_rect);
 
   if (DrawsContent())
@@ skipping 68 matching lines @@
 
   layer->SetTransformTreeIndex(transform_tree_index());
   layer->SetEffectTreeIndex(effect_tree_index());
   layer->SetClipTreeIndex(clip_tree_index());
   layer->SetScrollTreeIndex(scroll_tree_index());
   layer->set_offset_to_transform_parent(offset_to_transform_parent_);
   layer->SetDoubleSided(double_sided_);
   layer->SetDrawsContent(DrawsContent());
   layer->SetHideLayerAndSubtree(hide_layer_and_subtree_);
   layer->SetHasRenderSurface(has_render_surface_);
+  // By the time we reach here, subtree_property_changed_ must have propagated
+  // to all descendants. So, it is enough to check it only for the current

[ajuma, 2016/02/10 15:31:32]

Also say why it will have already propagated to descendants.

[jaydasika, 2016/02/10 19:18:25]

Done.

+  // layer.
+  if (subtree_property_changed_)
+    layer->NoteLayerPropertyChanged();
   layer->SetForceRenderSurface(force_render_surface_);
   if (!layer->FilterIsAnimatingOnImplOnly() && !FilterIsAnimating())
     layer->SetFilters(filters_);
   DCHECK(!(FilterIsAnimating() && layer->FilterIsAnimatingOnImplOnly()));
   layer->SetBackgroundFilters(background_filters());
   layer->SetMasksToBounds(masks_to_bounds_);
   layer->set_main_thread_scrolling_reasons(main_thread_scrolling_reasons_);
   layer->SetNonFastScrollableRegion(non_fast_scrollable_region_);
   layer->SetTouchEventHandlerRegion(touch_event_handler_region_);
   layer->SetContentsOpaque(contents_opaque_);
@@ skipping 117 matching lines @@
     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.
   stacking_order_changed_ = false;
+  subtree_property_changed_ = false;
   update_rect_ = gfx::Rect();
 
   needs_push_properties_ = false;
   num_dependents_need_push_properties_ = 0;
 }
 
 void Layer::SetTypeForProtoSerialization(proto::LayerNode* proto) const {
   proto->set_type(proto::LayerType::LAYER);
 }
 
@@ skipping 115 matching lines @@
   base->set_transform_free_index(transform_tree_index_);
   base->set_effect_tree_index(effect_tree_index_);
   base->set_clip_tree_index(clip_tree_index_);
   base->set_scroll_tree_index(scroll_tree_index_);
   Vector2dFToProto(offset_to_transform_parent_,
                    base->mutable_offset_to_transform_parent());
   base->set_double_sided(double_sided_);
   base->set_draws_content(draws_content_);
   base->set_hide_layer_and_subtree(hide_layer_and_subtree_);
   base->set_has_render_surface(has_render_surface_);
+  base->set_subtree_property_changed(subtree_property_changed_);
 
   // TODO(nyquist): Add support for serializing FilterOperations for
   // |filters_| and |background_filters_|. See crbug.com/541321.
 
   base->set_masks_to_bounds(masks_to_bounds_);
   base->set_main_thread_scrolling_reasons(main_thread_scrolling_reasons_);
   RegionToProto(non_fast_scrollable_region_,
                 base->mutable_non_fast_scrollable_region());
   RegionToProto(touch_event_handler_region_,
                 base->mutable_touch_event_handler_region());
@@ skipping 68 matching lines @@
   transform_tree_index_ = base.transform_free_index();
   effect_tree_index_ = base.effect_tree_index();
   clip_tree_index_ = base.clip_tree_index();
   scroll_tree_index_ = base.scroll_tree_index();
   offset_to_transform_parent_ =
       ProtoToVector2dF(base.offset_to_transform_parent());
   double_sided_ = base.double_sided();
   draws_content_ = base.draws_content();
   hide_layer_and_subtree_ = base.hide_layer_and_subtree();
   has_render_surface_ = base.has_render_surface();
+  subtree_property_changed_ = base.subtree_property_changed();
   masks_to_bounds_ = base.masks_to_bounds();
   main_thread_scrolling_reasons_ = base.main_thread_scrolling_reasons();
   non_fast_scrollable_region_ =
       RegionFromProto(base.non_fast_scrollable_region());
   touch_event_handler_region_ =
       RegionFromProto(base.touch_event_handler_region());
   contents_opaque_ = base.contents_opaque();
   opacity_ = base.opacity();
   blend_mode_ = SkXfermodeModeFromProto(base.blend_mode());
   is_root_for_isolated_group_ = base.is_root_for_isolated_group();
@@ skipping 131 matching lines @@
 
 void Layer::SetHasRenderSurface(bool has_render_surface) {
   if (has_render_surface_ == has_render_surface)
     return;
   has_render_surface_ = has_render_surface;
   // We do not need SetNeedsCommit here, since this is only ever called
   // during a commit, from CalculateDrawProperties using property trees.
   SetNeedsPushProperties();
 }
 
+void Layer::SetSubtreePropertyChanged() {
+  subtree_property_changed_ = true;
+}
+
 gfx::ScrollOffset Layer::ScrollOffsetForAnimation() const {
   return CurrentScrollOffset();
 }
 
 // On<Property>Animated is called due to an ongoing accelerated animation.
 // Since this animation is also being run on the compositor thread, there
 // is no need to request a commit to push this value over, so the value is
 // set directly rather than by calling Set<Property>.
 void Layer::OnFilterAnimated(const FilterOperations& filters) {
   filters_ = filters;
@@ skipping 293 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