cc : Store surface layer ids on LayerTreeHost and push them at commit

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 299 matching lines @@
   bool did_navigate = content_source_id_ != sync_tree->content_source_id();
   if (did_navigate)
     host_impl->ClearImageCacheOnNavigation();
 
   {
     TRACE_EVENT0("cc", "LayerTreeHostInProcess::PushProperties");
 
     PushPropertyTreesTo(sync_tree);
     sync_tree->lifecycle().AdvanceTo(LayerTreeLifecycle::kSyncedPropertyTrees);
 
+    PushSurfaceIdsTo(sync_tree);
     TreeSynchronizer::PushLayerProperties(this, sync_tree);
     sync_tree->lifecycle().AdvanceTo(
         LayerTreeLifecycle::kSyncedLayerProperties);
 
     PushLayerTreePropertiesTo(sync_tree);
     PushLayerTreeHostPropertiesTo(host_impl);
 
     sync_tree->PassSwapPromises(swap_promise_manager_.TakeSwapPromises());
 
     // TODO(pdr): Move this into PushPropertyTreesTo or introduce a lifecycle
@@ skipping 755 matching lines @@
                                  bool* content_is_suitable_for_gpu) {
   base::AutoReset<bool> painting(&in_paint_layer_contents_, true);
   bool did_paint_content = false;
   for (const auto& layer : update_layer_list) {
     did_paint_content |= layer->Update();
     *content_is_suitable_for_gpu &= layer->IsSuitableForGpuRasterization();
   }
   return did_paint_content;
 }
 
+void LayerTreeHost::AddSurfaceLayerId(const SurfaceId& surface_id) {
+  surface_layer_ids_.insert(surface_id);
+  needs_surface_ids_sync_ = true;
+}
+
+void LayerTreeHost::RemoveSurfaceLayerId(const SurfaceId& surface_id) {
+  surface_layer_ids_.erase(surface_id);
+  needs_surface_ids_sync_ = true;
+}
+
+const base::flat_set<SurfaceId>& LayerTreeHost::SurfaceLayerIds() const {
+  return surface_layer_ids_;
+}
+
 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_;
@@ skipping 111 matching lines @@
   if (pending_page_scale_animation_) {
     tree_impl->SetPendingPageScaleAnimation(
         std::move(pending_page_scale_animation_));
   }
 
   DCHECK(!tree_impl->ViewportSizeInvalid());
 
   tree_impl->set_has_ever_been_drawn(false);
 }
 
+void LayerTreeHost::PushSurfaceIdsTo(LayerTreeImpl* tree_impl) {
+  if (needs_surface_ids_sync()) {
+    tree_impl->ClearSurfaceLayerIds();
+    tree_impl->SetSurfaceLayerIds(SurfaceLayerIds());
+    // Reset for next update
+    set_needs_surface_ids_sync(false);
+  }
+}
+
 void LayerTreeHost::PushLayerTreeHostPropertiesTo(
     LayerTreeHostImpl* host_impl) {
   host_impl->SetHasGpuRasterizationTrigger(has_gpu_rasterization_trigger_);
   host_impl->SetContentIsSuitableForGpuRasterization(
       content_is_suitable_for_gpu_rasterization_);
   RecordGpuRasterizationHistogram(host_impl);
 
   host_impl->SetViewportSize(device_viewport_size_);
   host_impl->SetDebugState(debug_state_);
 }
@@ skipping 249 matching lines @@
 void LayerTreeHost::SetNeedsDisplayOnAllLayers() {
   for (auto* layer : *this)
     layer->SetNeedsDisplay();
 }
 
 void LayerTreeHost::SetHasCopyRequest(bool has_copy_request) {
   has_copy_request_ = has_copy_request;
 }
 
 }  // namespace cc