cc : Make tree synchronization independent of layer tree hierarchy (2)

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 32 matching lines @@
 
 namespace cc {
 
 base::StaticAtomicSequenceNumber g_next_layer_id;
 
 scoped_refptr<Layer> Layer::Create(const LayerSettings& settings) {
   return make_scoped_refptr(new Layer(settings));
 }
 
 Layer::Layer(const LayerSettings& settings)
-    : needs_push_properties_(false),
-      num_dependents_need_push_properties_(0),
-      // Layer IDs start from 1.
+    :  // Layer IDs start from 1.
       layer_id_(g_next_layer_id.GetNext() + 1),
       ignore_set_needs_commit_(false),
       sorting_context_id_(0),
       parent_(nullptr),
       layer_tree_host_(nullptr),
       scroll_clip_layer_id_(INVALID_ID),
       num_descendants_that_draw_content_(0),
       transform_tree_index_(-1),
       effect_tree_index_(-1),
       clip_tree_index_(-1),
@@ skipping 77 matching lines @@
 
   if (layer_tree_host_) {
     layer_tree_host_->property_trees()->needs_rebuild = true;
     layer_tree_host_->UnregisterLayer(this);
   }
   if (host) {
     host->property_trees()->needs_rebuild = true;
     host->RegisterLayer(this);
   }
 
+  layer_tree_host_ = host;

[jaydasika, 2016/03/17 23:38:37]

This is to ensure that layer is added to right set when we invalidate property
tree indices.

   InvalidatePropertyTreesIndices();
 
-  layer_tree_host_ = host;
-
   // When changing hosts, the layer needs to commit its properties to the impl
   // side for the new host.
   SetNeedsPushProperties();
 
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->SetLayerTreeHost(host);
 
   if (mask_layer_.get())
     mask_layer_->SetLayerTreeHost(host);
   if (replica_layer_.get())
@@ skipping 50 matching lines @@
 }
 
 void Layer::SetNextCommitWaitsForActivation() {
   if (!layer_tree_host_)
     return;
 
   layer_tree_host_->SetNextCommitWaitsForActivation();
 }
 
 void Layer::SetNeedsPushProperties() {
-  if (needs_push_properties_)
-    return;
-  if (!parent_should_know_need_push_properties() && parent_)
-    parent_->AddDependentNeedsPushProperties();
-  needs_push_properties_ = true;
-}
-
-void Layer::AddDependentNeedsPushProperties() {
-  DCHECK_GE(num_dependents_need_push_properties_, 0);
-
-  if (!parent_should_know_need_push_properties() && parent_)
-    parent_->AddDependentNeedsPushProperties();
-
-  num_dependents_need_push_properties_++;
-}
-
-void Layer::RemoveDependentNeedsPushProperties() {
-  num_dependents_need_push_properties_--;
-  DCHECK_GE(num_dependents_need_push_properties_, 0);
-
-  if (!parent_should_know_need_push_properties() && parent_)
-      parent_->RemoveDependentNeedsPushProperties();
+  if (layer_tree_host_)
+    layer_tree_host_->AddLayerShouldPushProperties(this);
 }
 
 bool Layer::IsPropertyChangeAllowed() const {
   if (!layer_tree_host_)
     return true;
 
   if (!layer_tree_host_->settings().strict_layer_property_change_checking)
     return true;
 
   return !layer_tree_host_->in_paint_layer_contents();
 }
 
 skia::RefPtr<SkPicture> Layer::GetPicture() const {
   return skia::RefPtr<SkPicture>();
 }
 
 void Layer::SetParent(Layer* layer) {
   DCHECK(!layer || !layer->HasAncestor(this));
 
-  if (parent_should_know_need_push_properties()) {
-    if (parent_)
-      parent_->RemoveDependentNeedsPushProperties();
-    if (layer)
-      layer->AddDependentNeedsPushProperties();
-  }
-
   parent_ = layer;
   SetLayerTreeHost(parent_ ? parent_->layer_tree_host() : nullptr);
 
   if (!layer_tree_host_)
     return;
 
   layer_tree_host_->property_trees()->needs_rebuild = true;
 }
 
 void Layer::AddChild(scoped_refptr<Layer> child) {
@@ skipping 1104 matching lines @@
 
   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.
   subtree_property_changed_ = false;
   update_rect_ = gfx::Rect();
 
-  needs_push_properties_ = false;
-  num_dependents_need_push_properties_ = 0;
+  layer_tree_host()->RemoveLayerShouldPushProperties(this);
 }
 
 void Layer::SetTypeForProtoSerialization(proto::LayerNode* proto) const {
   proto->set_type(proto::LayerNode::LAYER);
 }
 
 void Layer::ToLayerNodeProto(proto::LayerNode* proto) const {
   proto->set_id(layer_id_);
   SetTypeForProtoSerialization(proto);
 
@@ skipping 69 matching lines @@
     replica_layer_ = LayerProtoConverter::FindOrAllocateAndConstruct(
         proto.replica_layer(), layer_map);
     replica_layer_->parent_ = this;
     replica_layer_->layer_tree_host_ = layer_tree_host_;
     replica_layer_->FromLayerNodeProto(proto.replica_layer(), layer_map);
   } else {
     replica_layer_ = nullptr;
   }
 }
 
-bool Layer::ToLayerPropertiesProto(proto::LayerUpdate* layer_update) {
-  if (!needs_push_properties_ && num_dependents_need_push_properties_ == 0)
-    return false;
-
+void Layer::ToLayerPropertiesProto(proto::LayerUpdate* layer_update) {
   // Always set properties metadata for serialized layers.
   proto::LayerProperties* proto = layer_update->add_layers();
   proto->set_id(layer_id_);
-  proto->set_needs_push_properties(needs_push_properties_);
-  proto->set_num_dependents_need_push_properties(
-      num_dependents_need_push_properties_);
-
-  if (needs_push_properties_)
-    LayerSpecificPropertiesToProto(proto);
-
-  needs_push_properties_ = false;
-
-  bool descendant_needs_push_properties =
-      num_dependents_need_push_properties_ > 0;
-  num_dependents_need_push_properties_ = 0;
-
-  return descendant_needs_push_properties;
+  LayerSpecificPropertiesToProto(proto);
 }
 
 void Layer::FromLayerPropertiesProto(const proto::LayerProperties& proto) {
   DCHECK(proto.has_id());
   DCHECK_EQ(layer_id_, proto.id());
-  DCHECK(proto.has_needs_push_properties());
-  needs_push_properties_ = proto.needs_push_properties();
-  DCHECK(proto.has_num_dependents_need_push_properties());
-  num_dependents_need_push_properties_ =
-      proto.num_dependents_need_push_properties();
-
-  if (!needs_push_properties_)
-    return;
-
   FromLayerSpecificPropertiesProto(proto);
 }
 
 void Layer::LayerSpecificPropertiesToProto(proto::LayerProperties* proto) {
   proto::BaseLayerProperties* base = proto->mutable_base();
 
   bool use_paint_properties = layer_tree_host_ &&
                               paint_properties_.source_frame_number ==
                                   layer_tree_host_->source_frame_number();
 
@@ skipping 553 matching lines @@
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, -1);
   return draw_property_utils::ScreenSpaceTransform(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc