cc: Remove map lookup from RenderSurfaceImpl::EffectTreeIndex

cc/trees/property_tree.cc

 // Copyright 2014 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 <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 973 matching lines @@
   return node->is_drawn && (!parent_node || parent_node->is_drawn);
 }
 
 void EffectTree::ResetChangeTracking() {
   for (int id = 1; id < static_cast<int>(size()); ++id) {
     EffectNode* node = Node(id);
     node->effect_changed = false;
   }
 }
 
+EffectTree::StableIdRenderSurfaceList
+EffectTree::CreateStableIdRenderSurfaceList() const {
+  StableIdRenderSurfaceList stable_id_render_surface_list;
+  for (int id = kContentsRootNodeId; id < static_cast<int>(size()); ++id) {
+    const EffectNode* node = Node(id);
+    if (node->render_surface) {
+      stable_id_render_surface_list.push_back(
+          std::make_pair(node->owning_layer_id, node->render_surface));
+    }
+  }
+  std::sort(stable_id_render_surface_list.begin(),
+            stable_id_render_surface_list.end());
+  return stable_id_render_surface_list;
+}
+
+void EffectTree::UpdateRenderSurfaceEffectIds(
+    const EffectTree::StableIdRenderSurfaceList& stable_id_render_surface_list,
+    LayerTreeImpl* layer_tree_impl) {
+  // Make a list of {stable id, node id} pairs for nodes that are supposed to
+  // have surfaces.
+  std::vector<std::pair<int, int>> stable_id_node_id_list;
+  for (int id = kContentsRootNodeId; id < static_cast<int>(size()); ++id) {
+    const EffectNode* node = Node(id);
+    if (node->has_render_surface) {
+      stable_id_node_id_list.push_back(
+          std::make_pair(node->owning_layer_id, node->id));
+    }
+  }
+
+  // Sort by stable id so that we can process the two lists cosequentially.
+  std::sort(stable_id_node_id_list.begin(), stable_id_node_id_list.end());
+
+  auto surface_list_it = stable_id_render_surface_list.begin();
+  auto node_id_list_it = stable_id_node_id_list.begin();
+  while (surface_list_it != stable_id_render_surface_list.end() &&
+         node_id_list_it != stable_id_node_id_list.end()) {
+    if (surface_list_it->first == node_id_list_it->first) {
+      RenderSurfaceImpl* surface = surface_list_it->second;
+      int node_id = node_id_list_it->second;
+      Node(node_id)->render_surface = surface;
+      surface->set_effect_tree_index(node_id);
+      surface_list_it++;
+      node_id_list_it++;
+      continue;
+    }
+
+    if (surface_list_it->first > node_id_list_it->first) {
+      node_id_list_it++;
+      continue;
+    }
+
+    // If we reach here, there's no longer an effect node with stable id
+    // |surface_list_it->first| that has a render surface. If there's no longer
+    // any corresponding layer either, there's nothing more to do since the
+    // surface owned by that layer would have been destroyed when the layer was
+    // destroyed. But if the layer still exists, we need to destroy the surface
+    // since it now has an invalid effect node id.
+    if (LayerImpl* layer_impl =
+            layer_tree_impl->LayerById(surface_list_it->first)) {
+      layer_impl->SetHasRenderSurface(false);
+    }
+    surface_list_it++;
+  }
+
+  while (surface_list_it != stable_id_render_surface_list.end()) {
+    if (LayerImpl* layer_impl =
+            layer_tree_impl->LayerById(surface_list_it->first)) {
+      layer_impl->SetHasRenderSurface(false);
+    }
+    surface_list_it++;
+  }
+}
+
 void TransformTree::UpdateNodeAndAncestorsHaveIntegerTranslations(
     TransformNode* node,
     TransformNode* parent_node) {
   DCHECK(parent_node);
   node->node_and_ancestors_have_only_integer_translation =
       node->to_parent.IsIdentityOrIntegerTranslation() &&
       parent_node->node_and_ancestors_have_only_integer_translation;
 }
 
 void ClipTree::SetViewportClip(gfx::RectF viewport_rect) {
@@ skipping 509 matching lines @@
   transform_id_to_index_map.clear();
   effect_id_to_index_map.clear();
   clip_id_to_index_map.clear();
   scroll_id_to_index_map.clear();
   always_use_active_tree_opacity_effect_ids.clear();
 
   needs_rebuild = true;
   full_tree_damaged = false;
   changed = false;
   non_root_surfaces_enabled = true;
+  sequence_number++;
 
 #if DCHECK_IS_ON()
   PropertyTrees tree;
   tree.transform_tree = transform_tree;
   tree.effect_tree = effect_tree;
   tree.clip_tree = clip_tree;
   tree.scroll_tree = scroll_tree;
   // Scroll offset map and currently scrolling node id may not be copied
   // during operator=.
   ScrollTree::ScrollOffsetMap& map = tree.scroll_tree.scroll_offset_map();
@@ skipping 445 matching lines @@
 
   const EffectNode* effect_node = effect_tree.Node(effect_id);
 
   bool success = GetFromTarget(transform_id, effect_id, transform);
   transform->Scale(effect_node->surface_contents_scale.x(),
                    effect_node->surface_contents_scale.y());
   return success;
 }
 
 }  // namespace cc