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

cc/trees/layer_tree_impl.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_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 72 matching lines @@
       min_page_scale_factor_(0),
       max_page_scale_factor_(0),
       device_scale_factor_(1.f),
       painted_device_scale_factor_(1.f),
       content_source_id_(0),
       elastic_overscroll_(elastic_overscroll),
       layers_(new OwnedLayerImplList),
       viewport_size_invalid_(false),
       needs_update_draw_properties_(true),
       needs_full_tree_sync_(true),
+      needs_surface_ids_sync_(false),
       next_activation_forces_redraw_(false),
       has_ever_been_drawn_(false),
       handle_visibility_changed_(false),
       have_scroll_event_handlers_(false),
       event_listener_properties_(),
       browser_controls_shrink_blink_size_(false),
       top_controls_height_(0),
       bottom_controls_height_(0),
       top_controls_shown_ratio_(top_controls_shown_ratio) {
   property_trees()->is_main_thread = false;
@@ skipping 311 matching lines @@
   target_tree->SetPropertyTrees(&property_trees_);
 
   ScrollNode* scrolling_node = nullptr;
   if (scrolling_element_id) {
     auto& scroll_tree = target_tree->property_trees()->scroll_tree;
     scrolling_node = scroll_tree.FindNodeFromElementId(scrolling_element_id);
   }
   target_tree->SetCurrentlyScrollingNode(scrolling_node);
 }
 
+void LayerTreeImpl::PushSurfaceIdsTo(LayerTreeImpl* target_tree) {
+  if (needs_surface_ids_sync()) {
+    target_tree->ClearSurfaceLayerIds();
+    target_tree->SetSurfaceLayerIds(SurfaceLayerIds());
+    // Reset for next update
+    set_needs_surface_ids_sync(false);
+  }
+}
+
 void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) {
   // The request queue should have been processed and does not require a push.
   DCHECK_EQ(ui_resource_request_queue_.size(), 0u);
 
+  PushSurfaceIdsTo(target_tree);
   target_tree->property_trees()->scroll_tree.PushScrollUpdatesFromPendingTree(
       &property_trees_, target_tree);
 
   if (next_activation_forces_redraw_) {
     target_tree->ForceRedrawNextActivation();
     next_activation_forces_redraw_ = false;
   }
 
   target_tree->PassSwapPromises(std::move(swap_promise_list_));
   swap_promise_list_.clear();
@@ skipping 773 matching lines @@
   gfx::SizeF content_size = root_scroll_layer->BoundsForScrolling();
   content_size.SetToMax(root_container_layer->BoundsForScrolling());
   return content_size;
 }
 
 LayerImpl* LayerTreeImpl::LayerById(int id) const {
   LayerImplMap::const_iterator iter = layer_id_map_.find(id);
   return iter != layer_id_map_.end() ? iter->second : nullptr;
 }
 
+void LayerTreeImpl::SetSurfaceLayerIds(
+    const base::flat_set<SurfaceId>& surface_layer_ids) {
+  DCHECK(surface_layer_ids_.empty());
+  surface_layer_ids_ = surface_layer_ids;
+  needs_surface_ids_sync_ = true;
+}
+
+const base::flat_set<SurfaceId>& LayerTreeImpl::SurfaceLayerIds() const {
+  return surface_layer_ids_;
+}
+
+void LayerTreeImpl::ClearSurfaceLayerIds() {
+  surface_layer_ids_.clear();
+  needs_surface_ids_sync_ = true;
+}
+
 void LayerTreeImpl::AddLayerShouldPushProperties(LayerImpl* layer) {
   layers_that_should_push_properties_.insert(layer);
 }
 
 void LayerTreeImpl::RemoveLayerShouldPushProperties(LayerImpl* layer) {
   layers_that_should_push_properties_.erase(layer);
 }
 
 std::unordered_set<LayerImpl*>&
 LayerTreeImpl::LayersThatShouldPushProperties() {
@@ skipping 499 matching lines @@
     layer->set_needs_show_scrollbars(true);
 }
 
 void LayerTreeImpl::UnregisterScrollLayer(LayerImpl* layer) {
   if (layer->scroll_clip_layer_id() == Layer::INVALID_ID)
     return;
 
   clip_scroll_map_.erase(layer->scroll_clip_layer_id());
 }
 
-void LayerTreeImpl::AddSurfaceLayer(LayerImpl* layer) {
-  DCHECK(std::find(surface_layers_.begin(), surface_layers_.end(), layer) ==
-         surface_layers_.end());
-  surface_layers_.push_back(layer);
-}
-
-void LayerTreeImpl::RemoveSurfaceLayer(LayerImpl* layer) {
-  LayerImplList::iterator it =
-      std::find(surface_layers_.begin(), surface_layers_.end(), layer);
-  DCHECK(it != surface_layers_.end());
-  surface_layers_.erase(it);
-}
-
 static bool PointHitsRect(
     const gfx::PointF& screen_space_point,
     const gfx::Transform& local_space_to_screen_space_transform,
     const gfx::Rect& local_space_rect,
     float* distance_to_camera) {
   // If the transform is not invertible, then assume that this point doesn't hit
   // this rect.
   gfx::Transform inverse_local_space_to_screen_space(
       gfx::Transform::kSkipInitialization);
   if (!local_space_to_screen_space_transform.GetInverse(
@@ skipping 354 matching lines @@
 
 void LayerTreeImpl::ResetAllChangeTracking() {
   layers_that_should_push_properties_.clear();
   // Iterate over all layers, including masks.
   for (auto& layer : *layers_)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking();
 }
 
 }  // namespace cc