cc: Move render surface ownership from layers to the effect tree

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 731 matching lines @@
 
 StickyPositionNodeData* TransformTree::StickyPositionData(int node_id) {
   TransformNode* node = Node(node_id);
   if (node->sticky_position_constraint_id == -1) {
     node->sticky_position_constraint_id = sticky_position_data_.size();
     sticky_position_data_.push_back(StickyPositionNodeData());
   }
   return &sticky_position_data_[node->sticky_position_constraint_id];
 }
 
-EffectTree::EffectTree() {}
+EffectTree::EffectTree() {
+  render_surfaces_.push_back(nullptr);
+}
 
 EffectTree::~EffectTree() {}
 
+int EffectTree::Insert(const EffectNode& tree_node, int parent_id) {
+  int node_id = PropertyTree<EffectNode>::Insert(tree_node, parent_id);
+  DCHECK_EQ(node_id, static_cast<int>(render_surfaces_.size()));
+
+  render_surfaces_.push_back(nullptr);
+  return node_id;
+}
+
 void EffectTree::clear() {
   PropertyTree<EffectNode>::clear();
   mask_layer_ids_.clear();
+  render_surfaces_.clear();
+  render_surfaces_.push_back(nullptr);
 
 #if DCHECK_IS_ON()
   EffectTree tree;
   DCHECK(tree == *this);
 #endif
 }
 
 float EffectTree::EffectiveOpacity(const EffectNode* node) const {
   return node->subtree_hidden ? 0.f : node->opacity;
 }
@@ skipping 201 matching lines @@
   if (node->has_copy_request)
     return node->id;
   else
     return EffectTree::kInvalidNodeId;
 }
 
 void EffectTree::AddMaskLayerId(int id) {
   mask_layer_ids_.push_back(id);
 }
 
+void EffectTree::UpdateRenderSurfaces(LayerTreeImpl* layer_tree_impl,
+                                      bool non_root_surfaces_enabled) {
+  for (int id = kContentsRootNodeId; id < static_cast<int>(size()); ++id) {
+    EffectNode* effect_node = Node(id);
+    bool needs_render_surface =
+        id == kContentsRootNodeId ||
+        (non_root_surfaces_enabled && effect_node->has_render_surface);
+    if (needs_render_surface == !!render_surfaces_[id])
+      continue;
+
+    if (needs_render_surface) {
+      render_surfaces_[id] = base::MakeUnique<RenderSurfaceImpl>(
+          layer_tree_impl, effect_node->owning_layer_id);
+      render_surfaces_[id]->set_effect_tree_index(id);
+    } else {
+      render_surfaces_[id].reset();
+    }
+  }
+}
+
 bool EffectTree::ContributesToDrawnSurface(int id) {
   // All drawn nodes contribute to drawn surface.
   // Exception : Nodes that are hidden and are drawn only for the sake of
   // copy requests.
   EffectNode* node = Node(id);
   EffectNode* parent_node = parent(node);
   return node->is_drawn && (!parent_node || parent_node->is_drawn);
 }
 
 void EffectTree::ResetChangeTracking() {
   for (int id = EffectTree::kContentsRootNodeId; id < static_cast<int>(size());
        ++id) {
-    EffectNode* node = Node(id);
-    node->effect_changed = false;
+    Node(id)->effect_changed = false;
+    if (render_surfaces_[id])
+      render_surfaces_[id]->ResetPropertyChangedFlags();
   }
 }
 
-EffectTree::StableIdRenderSurfaceList
-EffectTree::CreateStableIdRenderSurfaceList() const {
-  StableIdRenderSurfaceList stable_id_render_surface_list;
+void EffectTree::TakeRenderSurfaces(
+    std::vector<std::unique_ptr<RenderSurfaceImpl>>* render_surfaces) {
   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));
+    if (render_surfaces_[id]) {
+      render_surfaces->push_back(std::move(render_surfaces_[id]));
     }
   }
-  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,
+bool EffectTree::CreateOrReuseRenderSurfaces(
+    std::vector<std::unique_ptr<RenderSurfaceImpl>>* old_render_surfaces,
     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);
+    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());
+  std::sort(old_render_surfaces->begin(), old_render_surfaces->end(),
+            [](const std::unique_ptr<RenderSurfaceImpl>& a,
+               const std::unique_ptr<RenderSurfaceImpl>& b) {
+              return a->id() < b->id();
+            });
 
-  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++;
+  bool render_surfaces_changed = false;
+  auto surfaces_list_it = old_render_surfaces->begin();
+  auto id_list_it = stable_id_node_id_list.begin();
+  while (surfaces_list_it != old_render_surfaces->end() &&
+         id_list_it != stable_id_node_id_list.end()) {
+    if ((*surfaces_list_it)->id() == id_list_it->first) {
+      int new_node_id = id_list_it->second;
+      render_surfaces_[new_node_id] = std::move(*surfaces_list_it);
+      render_surfaces_[new_node_id]->set_effect_tree_index(new_node_id);
+      surfaces_list_it++;
+      id_list_it++;
       continue;
     }
 
-    if (surface_list_it->first > node_id_list_it->first) {
-      node_id_list_it++;
-      continue;
+    render_surfaces_changed = true;
+
+    if ((*surfaces_list_it)->id() > id_list_it->first) {
+      int new_node_id = id_list_it->second;
+      render_surfaces_[new_node_id] = base::MakeUnique<RenderSurfaceImpl>(
+          layer_tree_impl, id_list_it->first);
+      render_surfaces_[new_node_id]->set_effect_tree_index(new_node_id);
+      id_list_it++;
+    } else {
+      surfaces_list_it++;
     }
-
-    // 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++;
+  if (surfaces_list_it != old_render_surfaces->end() ||
+      id_list_it != stable_id_node_id_list.end()) {
+    render_surfaces_changed = true;
   }
+
+  while (id_list_it != stable_id_node_id_list.end()) {
+    int new_node_id = id_list_it->second;
+    render_surfaces_[new_node_id] =
+        base::MakeUnique<RenderSurfaceImpl>(layer_tree_impl, id_list_it->first);
+    render_surfaces_[new_node_id]->set_effect_tree_index(new_node_id);
+    id_list_it++;
+  }
+
+  return render_surfaces_changed;
 }
 
 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;
 }
@@ skipping 13 matching lines @@
   DCHECK_GT(size(), min_size);
   return Node(kViewportNodeId)->clip;
 }
 
 bool ClipTree::operator==(const ClipTree& other) const {
   return PropertyTree::operator==(other);
 }
 
 EffectTree& EffectTree::operator=(const EffectTree& from) {
   PropertyTree::operator=(from);
+  render_surfaces_.resize(size());
   mask_layer_ids_ = from.mask_layer_ids_;
   // copy_requests_ are omitted here, since these need to be moved rather
   // than copied or assigned.
+
   return *this;
 }
 
 bool EffectTree::operator==(const EffectTree& other) const {
   return PropertyTree::operator==(other) &&
          mask_layer_ids_ == other.mask_layer_ids_;
 }
 
 ScrollTree::ScrollTree()
     : currently_scrolling_node_id_(kInvalidNodeId),
@@ skipping 982 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