Transfer LayerImpl ownership to LayerTreeImpl

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 39 matching lines @@
 namespace cc {
 
 LayerTreeImpl::LayerTreeImpl(
     LayerTreeHostImpl* layer_tree_host_impl,
     scoped_refptr<SyncedProperty<ScaleGroup>> page_scale_factor,
     scoped_refptr<SyncedTopControls> top_controls_shown_ratio,
     scoped_refptr<SyncedElasticOverscroll> elastic_overscroll)
     : layer_tree_host_impl_(layer_tree_host_impl),
       source_frame_number_(-1),
       is_first_frame_after_commit_tracker_(-1),
-      hud_layer_(0),
+      root_layer_(nullptr),
+      hud_layer_(nullptr),
       background_color_(0),
       has_transparent_background_(false),
       last_scrolled_layer_id_(Layer::INVALID_ID),
       overscroll_elasticity_layer_id_(Layer::INVALID_ID),
       page_scale_layer_id_(Layer::INVALID_ID),
       inner_viewport_scroll_layer_id_(Layer::INVALID_ID),
       outer_viewport_scroll_layer_id_(Layer::INVALID_ID),
       page_scale_factor_(page_scale_factor),
       min_page_scale_factor_(0),
       max_page_scale_factor_(0),
       device_scale_factor_(1.f),
       painted_device_scale_factor_(1.f),
       elastic_overscroll_(elastic_overscroll),
+      layers_(new OwnedLayerImplList),
       viewport_size_invalid_(false),
       needs_update_draw_properties_(true),
       needs_full_tree_sync_(true),
       next_activation_forces_redraw_(false),
       has_ever_been_drawn_(false),
       render_surface_layer_list_id_(0),
       have_scroll_event_handlers_(false),
       event_listener_properties_(),
       top_controls_shrink_blink_size_(false),
       top_controls_height_(0),
       top_controls_shown_ratio_(top_controls_shown_ratio) {
   property_trees()->is_main_thread = false;
 }
 
 LayerTreeImpl::~LayerTreeImpl() {
   BreakSwapPromises(IsActiveTree() ? SwapPromise::SWAP_FAILS
                                    : SwapPromise::ACTIVATION_FAILS);
 
   // Need to explicitly clear the tree prior to destroying this so that
   // the LayerTreeImpl pointer is still valid in the LayerImpl dtor.
   DCHECK(!root_layer_);
   DCHECK(layers_with_copy_output_request_.empty());
 }
 
 void LayerTreeImpl::Shutdown() {
+  if (root_layer_)
+    RemoveLayer(root_layer_->id());
   root_layer_ = nullptr;
 }
 
 void LayerTreeImpl::ReleaseResources() {
   if (root_layer_) {
     LayerTreeHostCommon::CallFunctionForSubtree(
-        root_layer_.get(), [](LayerImpl* layer) { layer->ReleaseResources(); });
+        root_layer_, [](LayerImpl* layer) { layer->ReleaseResources(); });
   }
 }
 
 void LayerTreeImpl::RecreateResources() {
   if (root_layer_) {
     LayerTreeHostCommon::CallFunctionForSubtree(
-        root_layer_.get(),
-        [](LayerImpl* layer) { layer->RecreateResources(); });
+        root_layer_, [](LayerImpl* layer) { layer->RecreateResources(); });
   }
 }
 
 void LayerTreeImpl::GatherFrameTimingRequestIds(
     std::vector<int64_t>* request_ids) {
   if (!root_layer_)
     return;
 
   // TODO(vmpstr): Early out if there are no requests on any of the layers. For
   // that, we need to inform LayerTreeImpl whenever there are requests when we
   // get them.
   LayerTreeHostCommon::CallFunctionForSubtree(
-      root_layer_.get(), [request_ids](LayerImpl* layer) {
+      root_layer_, [request_ids](LayerImpl* layer) {
         layer->GatherFrameTimingRequestIds(request_ids);
       });
 }
 
 bool LayerTreeImpl::IsViewportLayerId(int id) const {
   if (id == inner_viewport_scroll_layer_id_ ||
       id == outer_viewport_scroll_layer_id_)
     return true;
   if (InnerViewportContainerLayer() &&
       id == InnerViewportContainerLayer()->id())
@@ skipping 125 matching lines @@
   if (scrollbar_needs_animation) {
     ScrollbarAnimationController* controller =
         layer_tree_host_impl_->ScrollbarAnimationControllerForId(
             scroll_layer_id);
     if (controller)
       controller->DidScrollUpdate(scroll_layer_size_did_change);
   }
 }
 
 void LayerTreeImpl::SetRootLayer(scoped_ptr<LayerImpl> layer) {
-  root_layer_ = std::move(layer);
-
+  if (root_layer_ && layer.get() != root_layer_)
+    RemoveLayer(root_layer_->id());
+  root_layer_ = layer.get();
+  if (layer)
+    AddLayer(std::move(layer));
   layer_tree_host_impl_->OnCanDrawStateChangedForTree();
 }
 
 LayerImpl* LayerTreeImpl::InnerViewportScrollLayer() const {
   return LayerById(inner_viewport_scroll_layer_id_);
 }
 
 LayerImpl* LayerTreeImpl::OuterViewportScrollLayer() const {
   return LayerById(outer_viewport_scroll_layer_id_);
 }
@@ skipping 15 matching lines @@
 
   if (InnerViewportScrollLayer())
     offset += InnerViewportScrollLayer()->MaxScrollOffset();
 
   if (OuterViewportScrollLayer())
     offset += OuterViewportScrollLayer()->MaxScrollOffset();
 
   return offset;
 }
 
-scoped_ptr<LayerImpl> LayerTreeImpl::DetachLayerTree() {
+scoped_ptr<OwnedLayerImplList> LayerTreeImpl::DetachLayers() {
+  root_layer_ = nullptr;
   render_surface_layer_list_.clear();
   set_needs_update_draw_properties();
-  return std::move(root_layer_);
+  scoped_ptr<OwnedLayerImplList> ret = std::move(layers_);
+  layers_.reset(new OwnedLayerImplList);
+  return ret;
+}
+
+void LayerTreeImpl::ClearLayers() {
+  SetRootLayer(nullptr);
+  DCHECK(layers_->empty());
 }
 
 static void UpdateClipTreeForBoundsDeltaOnLayer(LayerImpl* layer,
                                                 ClipTree* clip_tree) {
   if (layer && layer->masks_to_bounds()) {
     ClipNode* clip_node = clip_tree->Node(layer->clip_tree_index());
     if (clip_node) {
       DCHECK_EQ(layer->id(), clip_node->owner_id);
       gfx::SizeF bounds = gfx::SizeF(layer->bounds());
       if (clip_node->data.clip.size() != bounds) {
@@ skipping 88 matching lines @@
     target_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(
         LayerTreeHostCommon::FindLayerInSubtree(target_tree->root_layer(),
                                                 hud_layer()->id())));
   else
     target_tree->set_hud_layer(NULL);
 
   target_tree->has_ever_been_drawn_ = false;
 }
 
 LayerListIterator LayerTreeImpl::begin() {
-  return LayerListIterator(root_layer_.get());
+  return LayerListIterator(root_layer_);
 }
 
 LayerListIterator LayerTreeImpl::end() {
   return LayerListIterator(nullptr);
 }
 
 LayerListReverseIterator LayerTreeImpl::rbegin() {
-  return LayerListReverseIterator(root_layer_.get());
+  return LayerListReverseIterator(root_layer_);
 }
 
 LayerListReverseIterator LayerTreeImpl::rend() {
   return LayerListReverseIterator(nullptr);
 }
 
 void LayerTreeImpl::AddToElementMap(LayerImpl* layer) {
   if (!layer->element_id() || !layer->mutable_properties())
     return;
 
@@ skipping 264 matching lines @@
   return gfx::ScaleSize(InnerViewportContainerLayer()->BoundsForScrolling(),
                         1.0f / current_page_scale_factor());
 }
 
 gfx::Rect LayerTreeImpl::RootScrollLayerDeviceViewportBounds() const {
   LayerImpl* root_scroll_layer = OuterViewportScrollLayer()
                                      ? OuterViewportScrollLayer()
                                      : InnerViewportScrollLayer();
   if (!root_scroll_layer || root_scroll_layer->children().empty())
     return gfx::Rect();
-  LayerImpl* layer = root_scroll_layer->children()[0].get();
+  LayerImpl* layer = root_scroll_layer->children()[0];
   return MathUtil::MapEnclosingClippedRect(layer->ScreenSpaceTransform(),
                                            gfx::Rect(layer->bounds()));
 }
 
 void LayerTreeImpl::ApplySentScrollAndScaleDeltasFromAbortedCommit() {
   DCHECK(IsActiveTree());
 
   page_scale_factor()->AbortCommit();
   top_controls_shown_ratio()->AbortCommit();
   elastic_overscroll()->AbortCommit();
@@ skipping 214 matching lines @@
     TRACE_EVENT_END1("cc", "LayerTreeImpl::UpdateDrawProperties::UpdateTiles",
                      "layers_updated_count", layers_updated_count);
   }
 
   DCHECK(!needs_update_draw_properties_)
       << "CalcDrawProperties should not set_needs_update_draw_properties()";
   return true;
 }
 
 void LayerTreeImpl::BuildPropertyTreesForTesting() {
-  LayerTreeHostCommon::PreCalculateMetaInformationForTesting(root_layer_.get());
+  LayerTreeHostCommon::PreCalculateMetaInformationForTesting(root_layer_);
   property_trees_.transform_tree.set_source_to_parent_updates_allowed(true);
   PropertyTreeBuilder::BuildPropertyTrees(
-      root_layer_.get(), PageScaleLayer(), InnerViewportScrollLayer(),
+      root_layer_, PageScaleLayer(), InnerViewportScrollLayer(),
       OuterViewportScrollLayer(), OverscrollElasticityLayer(),
       elastic_overscroll()->Current(IsActiveTree()),
       current_page_scale_factor(), device_scale_factor(),
       gfx::Rect(DrawViewportSize()), layer_tree_host_impl_->DrawTransform(),
       &property_trees_);
   property_trees_.transform_tree.set_source_to_parent_updates_allowed(false);
 }
 
 void LayerTreeImpl::IncrementRenderSurfaceListIdForTesting() {
   render_surface_layer_list_id_++;
@@ skipping 22 matching lines @@
   gfx::SizeF content_size =
       root_scroll_layer->children()[0]->BoundsForScrolling();
   gfx::SizeF viewport_size =
       root_scroll_layer->scroll_clip_layer()->BoundsForScrolling();
 
   content_size.SetToMax(viewport_size);
   return content_size;
 }
 
 LayerImpl* LayerTreeImpl::LayerById(int id) const {
-  LayerIdMap::const_iterator iter = layer_id_map_.find(id);
+  LayerImplMap::const_iterator iter = layer_id_map_.find(id);
   return iter != layer_id_map_.end() ? iter->second : NULL;
 }
 
 void LayerTreeImpl::AddLayerShouldPushProperties(LayerImpl* layer) {
   layers_that_should_push_properties_.insert(layer);
 }
 
 void LayerTreeImpl::RemoveLayerShouldPushProperties(LayerImpl* layer) {
   layers_that_should_push_properties_.erase(layer);
 }
@@ skipping 15 matching lines @@
       layer->id(),
       IsActiveTree() ? LayerTreeType::ACTIVE : LayerTreeType::PENDING);
 }
 
 void LayerTreeImpl::UnregisterLayer(LayerImpl* layer) {
   DCHECK(LayerById(layer->id()));
   layer_tree_host_impl_->animation_host()->UnregisterLayer(
       layer->id(),
       IsActiveTree() ? LayerTreeType::ACTIVE : LayerTreeType::PENDING);
   layer_id_map_.erase(layer->id());
+  DCHECK_NE(root_layer_, layer);
+}
+
+// These manage ownership of the LayerImpl.
+void LayerTreeImpl::AddLayer(scoped_ptr<LayerImpl> layer) {
+  DCHECK(std::find(layers_->begin(), layers_->end(), layer) == layers_->end());
+  layers_->push_back(std::move(layer));
+  set_needs_update_draw_properties();
+}
+
+scoped_ptr<LayerImpl> LayerTreeImpl::RemoveLayer(int id) {
+  if (root_layer_ && root_layer_->id() == id)
+    root_layer_ = nullptr;
+  for (auto it = layers_->begin(); it != layers_->end(); ++it) {
+    if ((*it) && (*it)->id() != id)
+      continue;
+    scoped_ptr<LayerImpl> ret = std::move(*it);
+    set_needs_update_draw_properties();
+    layers_->erase(it);
+    return ret;
+  }
+  return nullptr;
 }
 
 size_t LayerTreeImpl::NumLayers() {
   return layer_id_map_.size();
 }
 
 void LayerTreeImpl::DidBecomeActive() {
   if (next_activation_forces_redraw_) {
     layer_tree_host_impl_->SetFullRootLayerDamage();
     next_activation_forces_redraw_ = false;
@@ skipping 1021 matching lines @@
 }
 
 void LayerTreeImpl::ResetAllChangeTracking(PropertyTrees::ResetFlags flag) {
   layers_that_should_push_properties_.clear();
   for (auto* layer : *this)
     layer->ResetChangeTracking();
   property_trees_.ResetAllChangeTracking(flag);
 }
 
 }  // namespace cc