Revert of cc : Make LayerImpl destruction independent of tree hierarchy

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>
@@ skipping 86 matching lines @@
 
   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);
 
-  // The mask and replica layers should have been removed already.
   if (mask_layer_)
-    DCHECK(!layer_tree_impl_->RemoveLayer(mask_layer_id_));
+    layer_tree_impl_->RemoveLayer(mask_layer_id_);
   if (replica_layer_)
-    DCHECK(!layer_tree_impl_->RemoveLayer(replica_layer_id_));
-  children_.clear();
+    layer_tree_impl_->RemoveLayer(replica_layer_id_);
+  ClearChildList();
 }
 
 void LayerImpl::AddChild(std::unique_ptr<LayerImpl> child) {
   child->SetParent(this);
   DCHECK_EQ(layer_tree_impl(), child->layer_tree_impl());
   children_.push_back(child.get());
   layer_tree_impl_->AddLayer(std::move(child));
 }
 
 std::unique_ptr<LayerImpl> LayerImpl::RemoveChildForTesting(LayerImpl* child) {
   auto it = std::find(children_.begin(), children_.end(), child);
   if (it != children_.end())
     children_.erase(it);
   layer_tree_impl()->property_trees()->RemoveIdFromIdToIndexMaps(child->id());
   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();
+}
+
 void LayerImpl::ClearLinksToOtherLayers() {
   children_.clear();
   mask_layer_ = nullptr;
   replica_layer_ = nullptr;
 }
 
 void LayerImpl::SetHasWillChangeTransformHint(bool has_will_change) {
   if (has_will_change_transform_hint_ == has_will_change)
     return;
   has_will_change_transform_hint_ = has_will_change;
@@ skipping 690 matching lines @@
 
   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;
 }
 
-std::unique_ptr<LayerImpl> LayerImpl::TakeReplicaLayerForTesting() {
+std::unique_ptr<LayerImpl> LayerImpl::TakeReplicaLayer() {
   replica_layer_id_ = -1;
   std::unique_ptr<LayerImpl> ret;
-  if (replica_layer_) {
-    if (replica_layer_->mask_layer())
-      replica_layer_->SetMaskLayer(nullptr);
+  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)
@@ skipping 495 matching lines @@
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       ScreenSpaceTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc