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 448 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());
+
+    TreeSynchronizer::PushLayerProperties(this, sync_tree);
 
     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.
   sync_tree->UpdatePropertyTreeScrollingAndAnimationFromMainThread();
 
@@ skipping 735 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;
   animation_host_->RegisterLayer(layer->id(), LayerTreeType::ACTIVE);
 }
 
 void LayerTreeHost::UnregisterLayer(Layer* layer) {
   DCHECK(LayerById(layer->id()));
   DCHECK(!in_paint_layer_contents_);
   animation_host_->UnregisterLayer(layer->id(), LayerTreeType::ACTIVE);
+  RemoveLayerShouldPushProperties(layer);
   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() {
   SetNeedsCommit();
 }
@@ skipping 141 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 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