Transfer LayerImpl ownership to LayerTreeImpl

cc/layers/layer_impl.cc

 // Copyright 2012 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/layers/layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <algorithm>
 #include <utility>
 
 #include "base/json/json_reader.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/animation/mutable_properties.h"
 #include "cc/base/math_util.h"
 #include "cc/base/simple_enclosed_region.h"
@@ skipping 19 matching lines @@
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
 LayerImpl::LayerImpl(LayerTreeImpl* tree_impl, int id)
     : parent_(nullptr),
       scroll_parent_(nullptr),
       clip_parent_(nullptr),
       mask_layer_id_(-1),
+      mask_layer_(nullptr),
       replica_layer_id_(-1),
+      replica_layer_(nullptr),
       layer_id_(id),
       layer_tree_impl_(tree_impl),
       scroll_clip_layer_id_(Layer::INVALID_ID),
       main_thread_scrolling_reasons_(
           MainThreadScrollingReason::kNotScrollingOnMain),
       user_scrollable_horizontal_(true),
       user_scrollable_vertical_(true),
       double_sided_(true),
       should_flatten_transform_(true),
       should_flatten_transform_from_property_tree_(false),
@@ skipping 47 matching lines @@
   if (!copy_requests_.empty() && layer_tree_impl_->IsActiveTree())
     layer_tree_impl()->RemoveLayerWithCopyOutputRequest(this);
   layer_tree_impl_->UnregisterScrollLayer(this);
   layer_tree_impl_->UnregisterLayer(this);
   layer_tree_impl_->RemoveLayerShouldPushProperties(this);
 
   layer_tree_impl_->RemoveFromElementMap(this);
 
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerImpl", this);
+
+  if (mask_layer_)
+    layer_tree_impl_->RemoveLayer(mask_layer_id_);
+  if (replica_layer_)
+    layer_tree_impl_->RemoveLayer(replica_layer_id_);
+  ClearChildList();
 }
 
 void LayerImpl::AddChild(scoped_ptr<LayerImpl> child) {
   child->SetParent(this);
   DCHECK_EQ(layer_tree_impl(), child->layer_tree_impl());
-  children_.push_back(std::move(child));
-  layer_tree_impl()->set_needs_update_draw_properties();
+  children_.push_back(child.get());
+  layer_tree_impl_->AddLayer(std::move(child));
 }
 
 scoped_ptr<LayerImpl> LayerImpl::RemoveChild(LayerImpl* child) {
-  for (OwnedLayerImplList::iterator it = children_.begin();
-       it != children_.end();
-       ++it) {
-    if (it->get() == child) {
-      scoped_ptr<LayerImpl> ret = std::move(*it);
-      children_.erase(it);
-      layer_tree_impl()->set_needs_update_draw_properties();
-      return ret;
-    }
-  }
-  return nullptr;
+  auto it = std::find(children_.begin(), children_.end(), child);
+  if (it != children_.end())
+    children_.erase(it);
+  return layer_tree_impl_->RemoveLayer(child->id());
 }
 
 void LayerImpl::SetParent(LayerImpl* parent) {
   parent_ = parent;
 }
 
 void LayerImpl::ClearChildList() {
   if (children_.empty())
     return;
-
+  for (auto* child : children_)
+    layer_tree_impl_->RemoveLayer(child->id());
   children_.clear();
-  layer_tree_impl()->set_needs_update_draw_properties();
 }
 
 bool LayerImpl::HasAncestor(const LayerImpl* ancestor) const {
   if (!ancestor)
     return false;
 
   for (const LayerImpl* layer = this; layer; layer = layer->parent()) {
     if (layer == ancestor)
       return true;
   }
@@ skipping 829 matching lines @@
 void LayerImpl::SetMaskLayer(scoped_ptr<LayerImpl> mask_layer) {
   int new_layer_id = mask_layer ? mask_layer->id() : -1;
 
   if (mask_layer) {
     DCHECK_EQ(layer_tree_impl(), mask_layer->layer_tree_impl());
     DCHECK_NE(new_layer_id, mask_layer_id_);
   } else if (new_layer_id == mask_layer_id_) {
     return;
   }
 
-  mask_layer_ = std::move(mask_layer);
+  if (mask_layer_)
+    layer_tree_impl_->RemoveLayer(mask_layer_->id());
+  mask_layer_ = mask_layer.get();
+  if (mask_layer_)
+    layer_tree_impl_->AddLayer(std::move(mask_layer));
+
   mask_layer_id_ = new_layer_id;
   if (mask_layer_)
     mask_layer_->SetParent(this);
 }
 
 scoped_ptr<LayerImpl> LayerImpl::TakeMaskLayer() {
   mask_layer_id_ = -1;
-  return std::move(mask_layer_);
+  scoped_ptr<LayerImpl> ret;
+  if (mask_layer_)
+    ret = layer_tree_impl_->RemoveLayer(mask_layer_->id());
+  mask_layer_ = nullptr;
+  return ret;
 }
 
 void LayerImpl::SetReplicaLayer(scoped_ptr<LayerImpl> replica_layer) {
   int new_layer_id = replica_layer ? replica_layer->id() : -1;
 
   if (replica_layer) {
     DCHECK_EQ(layer_tree_impl(), replica_layer->layer_tree_impl());
     DCHECK_NE(new_layer_id, replica_layer_id_);
   } else if (new_layer_id == replica_layer_id_) {
     return;
   }
 
-  replica_layer_ = std::move(replica_layer);
+  if (replica_layer_)
+    layer_tree_impl_->RemoveLayer(replica_layer_->id());
+  replica_layer_ = replica_layer.get();
+  if (replica_layer_)
+    layer_tree_impl_->AddLayer(std::move(replica_layer));
+
   replica_layer_id_ = new_layer_id;
   if (replica_layer_)
     replica_layer_->SetParent(this);
 }
 
 scoped_ptr<LayerImpl> LayerImpl::TakeReplicaLayer() {
   replica_layer_id_ = -1;
-  return std::move(replica_layer_);
+  scoped_ptr<LayerImpl> ret;
+  if (replica_layer_)
+    ret = layer_tree_impl_->RemoveLayer(replica_layer_->id());
+  replica_layer_ = nullptr;
+  return ret;
 }
 
 ScrollbarLayerImplBase* LayerImpl::ToScrollbarLayer() {
   return nullptr;
 }
 
 void LayerImpl::SetDrawsContent(bool draws_content) {
   if (draws_content_ == draws_content)
     return;
 
@@ skipping 541 matching lines @@
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       DrawTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc