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

cc/trees/layer_tree_host.cc

 // Copyright 2011 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/trees/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 464 matching lines @@
     sync_tree->set_ui_resource_request_queue(ui_resource_request_queue_);
     ui_resource_request_queue_.clear();
   }
 
   DCHECK(!sync_tree->ViewportSizeInvalid());
 
   sync_tree->set_has_ever_been_drawn(false);
 
   {
     TRACE_EVENT0("cc", "LayerTreeHost::PushProperties");
-    TreeSynchronizer::PushProperties(root_layer(), sync_tree->root_layer());
+
+    std::unordered_set<Layer*> layers_that_should_push_properties =
+        layers_that_should_push_properties_;
+    for (auto layer : layers_that_should_push_properties) {
+      LayerImpl* sync_tree_layer = sync_tree->LayerById(layer->id());
+      DCHECK(sync_tree_layer);
+      layer->PushPropertiesTo(sync_tree_layer);
+    }
 
     if (animation_host_) {
       TRACE_EVENT0("cc", "LayerTreeHost::AnimationHost::PushProperties");
       DCHECK(host_impl->animation_host());
       animation_host_->PushPropertiesTo(host_impl->animation_host());
     }
   }
 
   // This must happen after synchronizing property trees and after push
   // properties, which updates property tree indices.
@@ skipping 756 matching lines @@
     scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
   client_->RecordFrameTimingEvents(std::move(composite_events),
                                    std::move(main_frame_events));
 }
 
 Layer* LayerTreeHost::LayerById(int id) const {
   LayerIdMap::const_iterator iter = layer_id_map_.find(id);
   return iter != layer_id_map_.end() ? iter->second : NULL;
 }
 
+void LayerTreeHost::AddLayerShouldPushProperties(Layer* layer) {
+  layers_that_should_push_properties_.insert(layer);
+}
+
+void LayerTreeHost::RemoveLayerShouldPushProperties(Layer* layer) {
+  layers_that_should_push_properties_.erase(layer);
+}
+
+std::unordered_set<Layer*>& LayerTreeHost::LayersThatShouldPushProperties() {
+  return layers_that_should_push_properties_;
+}
+
+bool LayerTreeHost::LayerNeedsPushPropertiesForTesting(Layer* layer) {
+  return layers_that_should_push_properties_.find(layer) !=
+         layers_that_should_push_properties_.end();
+}
+
 void LayerTreeHost::RegisterLayer(Layer* layer) {
   DCHECK(!LayerById(layer->id()));
   DCHECK(!in_paint_layer_contents_);
   layer_id_map_[layer->id()] = layer;
   if (animation_host_)
     animation_host_->RegisterLayer(layer->id(), LayerTreeType::ACTIVE);
 }
 
 void LayerTreeHost::UnregisterLayer(Layer* layer) {
   DCHECK(LayerById(layer->id()));
   DCHECK(!in_paint_layer_contents_);
+  RemoveLayerShouldPushProperties(layer);

[ajuma, 2016/03/18 14:33:16]

Do we have a test that removes a layer needing push properties from its host,
verifying that this layer's id is no longer in that host's set of layers needing
push properties?

[jaydasika, 2016/03/19 02:17:58]

There are many tests that check this implicitly. More than 40 tests were
crashing when InvalidatePropertyTrees in layer.cc was trying to add the layer
back to the old layer tree host's set. 

   if (animation_host_)
     animation_host_->UnregisterLayer(layer->id(), LayerTreeType::ACTIVE);
   layer_id_map_.erase(layer->id());
 }
 
 bool LayerTreeHost::IsLayerInTree(int layer_id, LayerTreeType tree_type) const {
   return tree_type == LayerTreeType::ACTIVE && LayerById(layer_id);
 }
 
 void LayerTreeHost::SetMutatorsNeedCommit() {
@@ skipping 169 matching lines @@
   // The LayerTreeHost on the server does not have an impl task runner.
   return compositor_mode_ == CompositorMode::REMOTE &&
          !task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHost::IsRemoteClient() const {
   return compositor_mode_ == CompositorMode::REMOTE &&
          task_runner_provider_->HasImplThread();
 }
 
-void LayerTreeHost::ToProtobufForCommit(proto::LayerTreeHost* proto) const {
-  // Not all fields are serialized, as they are eiher not needed for a commit,
+void LayerTreeHost::ToProtobufForCommit(proto::LayerTreeHost* proto) {
+  // Not all fields are serialized, as they are either not needed for a commit,
   // or implementation isn't ready yet.
   // Unsupported items:
   // - animations
   // - UI resources
   // - instrumentation of stats
   // - histograms
   // Skipped items:
   // - SwapPromise as they are mostly used for perf measurements.
   // - The bitmap and GPU memory related items.
   // Other notes:
   // - The output surfaces are only valid on the client-side so they are
   //   therefore not serialized.
   // - LayerTreeSettings are needed only during construction of the
   //   LayerTreeHost, so they are serialized outside of the LayerTreeHost
   //   serialization.
   // - The |visible_| flag will be controlled from the client separately and
   //   will need special handling outside of the serialization of the
   //   LayerTreeHost.
   // TODO(nyquist): Figure out how to support animations. See crbug.com/570376.
   proto->set_needs_full_tree_sync(needs_full_tree_sync_);
   proto->set_needs_meta_info_recomputation(needs_meta_info_recomputation_);
   proto->set_source_frame_number(source_frame_number_);
   proto->set_meta_information_sequence_number(
       meta_information_sequence_number_);
   LayerProtoConverter::SerializeLayerHierarchy(root_layer_,
                                                proto->mutable_root_layer());
-  LayerProtoConverter::SerializeLayerProperties(root_layer_.get(),
+  // layers_that_should_push_properties_ should be serialized before layer
+  // properties because the it is cleared during the properties serialization.
+  for (auto layer : layers_that_should_push_properties_)
+    proto->add_layers_that_should_push_properties(layer->id());
+  LayerProtoConverter::SerializeLayerProperties(this,
                                                 proto->mutable_layer_updates());
   proto->set_hud_layer_id(hud_layer_ ? hud_layer_->id() : Layer::INVALID_ID);
   debug_state_.ToProtobuf(proto->mutable_debug_state());
   SizeToProto(device_viewport_size_, proto->mutable_device_viewport_size());
   proto->set_top_controls_shrink_blink_size(top_controls_shrink_blink_size_);
   proto->set_top_controls_height(top_controls_height_);
   proto->set_top_controls_shown_ratio(top_controls_shown_ratio_);
   proto->set_device_scale_factor(device_scale_factor_);
   proto->set_painted_device_scale_factor(painted_device_scale_factor_);
   proto->set_page_scale_factor(page_scale_factor_);
@@ skipping 48 matching lines @@
       root_layer_->SetLayerTreeHost(nullptr);
     root_layer_ = new_root_layer;
     root_layer_->SetLayerTreeHost(this);
   }
 
   // Populate layer_id_map_ with the new layers.
   layer_id_map_.clear();
   LayerTreeHostCommon::CallFunctionForSubtree(
       root_layer(),
       [this](Layer* layer) { layer_id_map_[layer->id()] = layer; });
+  for (auto layer_id : proto.layers_that_should_push_properties())
+    layers_that_should_push_properties_.insert(layer_id_map_[layer_id]);
 
   LayerProtoConverter::DeserializeLayerProperties(root_layer_.get(),
                                                   proto.layer_updates());
 
   debug_state_.FromProtobuf(proto.debug_state());
   device_viewport_size_ = ProtoToSize(proto.device_viewport_size());
   top_controls_shrink_blink_size_ = proto.top_controls_shrink_blink_size();
   top_controls_height_ = proto.top_controls_height();
   top_controls_shown_ratio_ = proto.top_controls_shown_ratio();
   device_scale_factor_ = proto.device_scale_factor();
@@ skipping 48 matching lines @@
   LayerTreeHostCommon::CallFunctionForSubtree(
       root_layer(), [seq_num](Layer* layer) {
         layer->set_property_tree_sequence_number(seq_num);
       });
 
   surface_id_namespace_ = proto.surface_id_namespace();
   next_surface_sequence_ = proto.next_surface_sequence();
 }
 
 }  // namespace cc