Transfer LayerImpl ownership to LayerTreeImpl

I have taken a very simple strategy. I have
retained all LayerImpl functions related to
transfer of ownership (AddChild, etc). These now
update raw pointers on the LayerImpl as well as
updating true ownership by talking to the LTI.

This allows most unit test code to remain as is.
LayerImpl's may be constructed and ownership may
be transferred just as it had been.

BUG=594026
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1801853002

Cr-Commit-Position: refs/heads/master@{#382619}

55 files changed, 581 insertions, 589 deletions

diff --git a/cc/BUILD.gn b/cc/BUILD.gn
index f5eacc1..5d5d1c6 100644
--- a/cc/BUILD.gn
+++ b/cc/BUILD.gn
@@ -130,12 +130,12 @@ component("cc") {
     "layers/layer.cc",
     "layers/layer.h",
     "layers/layer_client.h",
+    "layers/layer_collections.h",
     "layers/layer_impl.cc",
     "layers/layer_impl.h",
     "layers/layer_iterator.h",
     "layers/layer_list_iterator.cc",
     "layers/layer_list_iterator.h",
-    "layers/layer_lists.h",
     "layers/layer_position_constraint.cc",
     "layers/layer_position_constraint.h",
     "layers/layer_proto_converter.cc",
diff --git a/cc/cc.gyp b/cc/cc.gyp
index 3600470..44d2b87 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -190,14 +190,14 @@
         'layers/io_surface_layer_impl.cc',
         'layers/io_surface_layer_impl.h',
         'layers/layer.cc',
-        'layers/layer.h',
         'layers/layer_client.h',
+        'layers/layer_collections.h',
+        'layers/layer.h',
         'layers/layer_impl.cc',
         'layers/layer_impl.h',
         'layers/layer_iterator.h',
         'layers/layer_list_iterator.cc',
         'layers/layer_list_iterator.h',
-        'layers/layer_lists.h',
         'layers/layer_position_constraint.cc',
         'layers/layer_position_constraint.h',
         'layers/layer_proto_converter.cc',
diff --git a/cc/debug/debug_rect_history.h b/cc/debug/debug_rect_history.h
index 0057817..62cf032 100644
--- a/cc/debug/debug_rect_history.h
+++ b/cc/debug/debug_rect_history.h
@@ -8,7 +8,7 @@
 #include <vector>
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
-#include "cc/layers/layer_lists.h"
+#include "cc/layers/layer_collections.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace cc {
diff --git a/cc/layers/layer.h b/cc/layers/layer.h
index 86c6e67..409a556 100644
--- a/cc/layers/layer.h
+++ b/cc/layers/layer.h
@@ -23,7 +23,7 @@
 #include "cc/debug/frame_timing_request.h"
 #include "cc/debug/micro_benchmark.h"
 #include "cc/input/input_handler.h"
-#include "cc/layers/layer_lists.h"
+#include "cc/layers/layer_collections.h"
 #include "cc/layers/layer_position_constraint.h"
 #include "cc/layers/paint_properties.h"
 #include "cc/output/filter_operations.h"
diff --git a/cc/layers/layer_collections.h b/cc/layers/layer_collections.h
new file mode 100644
index 0000000..6830261
--- /dev/null
+++ b/cc/layers/layer_collections.h
@@ -0,0 +1,27 @@
+// Copyright 2016 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.
+
+#ifndef CC_LAYERS_LAYER_COLLECTIONS_H_
+#define CC_LAYERS_LAYER_COLLECTIONS_H_
+
+#include <unordered_map>
+#include <vector>
+
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "cc/base/cc_export.h"
+
+namespace cc {
+class Layer;
+class LayerImpl;
+
+using LayerList = std::vector<scoped_refptr<Layer>>;
+using OwnedLayerImplList = std::vector<scoped_ptr<LayerImpl>>;
+using LayerImplList = std::vector<LayerImpl*>;
+using OwnedLayerImplMap = std::unordered_map<int, scoped_ptr<LayerImpl>>;
+using LayerImplMap = std::unordered_map<int, LayerImpl*>;
+
+}  // namespace cc
+
+#endif  // CC_LAYERS_LAYER_COLLECTIONS_H_
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index d2c627f..3ef1ab6 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -7,6 +7,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <algorithm>
 #include <utility>
 
 #include "base/json/json_reader.h"
@@ -46,7 +47,9 @@ LayerImpl::LayerImpl(LayerTreeImpl* tree_impl, int id)
       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),
@@ -114,27 +117,26 @@ LayerImpl::~LayerImpl() {
 
   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) {
@@ -144,9 +146,9 @@ void LayerImpl::SetParent(LayerImpl* 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 {
@@ -996,7 +998,12 @@ void LayerImpl::SetMaskLayer(scoped_ptr<LayerImpl> mask_layer) {
     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);
@@ -1004,7 +1011,11 @@ void LayerImpl::SetMaskLayer(scoped_ptr<LayerImpl> mask_layer) {
 
 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) {
@@ -1017,7 +1028,12 @@ void LayerImpl::SetReplicaLayer(scoped_ptr<LayerImpl> replica_layer) {
     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);
@@ -1025,7 +1041,11 @@ void LayerImpl::SetReplicaLayer(scoped_ptr<LayerImpl> replica_layer) {
 
 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() {
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index 31cdfba..97ff96c 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -24,7 +24,7 @@
 #include "cc/debug/frame_timing_request.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/draw_properties.h"
-#include "cc/layers/layer_lists.h"
+#include "cc/layers/layer_collections.h"
 #include "cc/layers/layer_position_constraint.h"
 #include "cc/layers/performance_properties.h"
 #include "cc/layers/render_surface_impl.h"
@@ -103,16 +103,13 @@ class CC_EXPORT LayerImpl {
   // Tree structure.
   LayerImpl* parent() { return parent_; }
   const LayerImpl* parent() const { return parent_; }
-  const OwnedLayerImplList& children() const { return children_; }
-  OwnedLayerImplList& children() { return children_; }
-  LayerImpl* child_at(size_t index) const { return children_[index].get(); }
+  const LayerImplList& children() const { return children_; }
+  LayerImplList& children() { return children_; }
+  LayerImpl* child_at(size_t index) const { return children_[index]; }
   void AddChild(scoped_ptr<LayerImpl> child);
   scoped_ptr<LayerImpl> RemoveChild(LayerImpl* child);
   void SetParent(LayerImpl* parent);
 
-  // Warning: This does not preserve tree structure invariants.
-  void ClearChildList();
-
   bool HasAncestor(const LayerImpl* ancestor) const;
 
   void SetScrollParent(LayerImpl* parent);
@@ -195,13 +192,13 @@ class CC_EXPORT LayerImpl {
   bool AnchestorHasCopyRequest() const;
 
   void SetMaskLayer(scoped_ptr<LayerImpl> mask_layer);
-  LayerImpl* mask_layer() { return mask_layer_.get(); }
-  const LayerImpl* mask_layer() const { return mask_layer_.get(); }
+  LayerImpl* mask_layer() { return mask_layer_; }
+  const LayerImpl* mask_layer() const { return mask_layer_; }
   scoped_ptr<LayerImpl> TakeMaskLayer();
 
   void SetReplicaLayer(scoped_ptr<LayerImpl> replica_layer);
-  LayerImpl* replica_layer() { return replica_layer_.get(); }
-  const LayerImpl* replica_layer() const { return replica_layer_.get(); }
+  LayerImpl* replica_layer() { return replica_layer_; }
+  const LayerImpl* replica_layer() const { return replica_layer_; }
   scoped_ptr<LayerImpl> TakeReplicaLayer();
 
   bool has_mask() const { return !!mask_layer_; }
@@ -636,6 +633,9 @@ class CC_EXPORT LayerImpl {
   gfx::Rect GetScaledEnclosingRectInTargetSpace(float scale) const;
 
  private:
+  // Warning: This does not preserve tree structure invariants.
+  void ClearChildList();
+
   void ValidateQuadResourcesInternal(DrawQuad* quad) const;
 
   void NoteLayerPropertyChangedForDescendantsInternal();
@@ -645,7 +645,7 @@ class CC_EXPORT LayerImpl {
 
   // Properties internal to LayerImpl
   LayerImpl* parent_;
-  OwnedLayerImplList children_;
+  LayerImplList children_;
 
   LayerImpl* scroll_parent_;
 
@@ -661,9 +661,9 @@ class CC_EXPORT LayerImpl {
   // mask_layer_ can be temporarily stolen during tree sync, we need this ID to
   // confirm newly assigned layer is still the previous one
   int mask_layer_id_;
-  scoped_ptr<LayerImpl> mask_layer_;
+  LayerImpl* mask_layer_;
   int replica_layer_id_;  // ditto
-  scoped_ptr<LayerImpl> replica_layer_;
+  LayerImpl* replica_layer_;
   int layer_id_;
   LayerTreeImpl* layer_tree_impl_;
 
diff --git a/cc/layers/layer_impl_unittest.cc b/cc/layers/layer_impl_unittest.cc
index e88d007..7e8c327 100644
--- a/cc/layers/layer_impl_unittest.cc
+++ b/cc/layers/layer_impl_unittest.cc
@@ -153,9 +153,9 @@ TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) {
       PropertyTrees::ResetFlags::ALL_TREES);
 
   root->AddChild(LayerImpl::Create(host_impl.active_tree(), 7));
-  LayerImpl* child = root->children()[0].get();
+  LayerImpl* child = root->children()[0];
   child->AddChild(LayerImpl::Create(host_impl.active_tree(), 8));
-  LayerImpl* grand_child = child->children()[0].get();
+  LayerImpl* grand_child = child->children()[0];
   root->SetScrollClipLayer(root_clip->id());
   host_impl.active_tree()->BuildPropertyTreesForTesting();
 
@@ -516,7 +516,7 @@ class LayerImplScrollTest : public testing::Test {
   }
 
   LayerImpl* layer() {
-    return host_impl_.active_tree()->root_layer()->children()[0].get();
+    return host_impl_.active_tree()->root_layer()->children()[0];
   }
 
   ScrollTree* scroll_tree(LayerImpl* layer_impl) {
diff --git a/cc/layers/layer_list_iterator.cc b/cc/layers/layer_list_iterator.cc
index 858440b..d64a946 100644
--- a/cc/layers/layer_list_iterator.cc
+++ b/cc/layers/layer_list_iterator.cc
@@ -22,9 +22,9 @@ LayerListIterator& LayerListIterator::operator++() {
     return *this;
 
   // case 1: descend.
-  const OwnedLayerImplList& current_list = current_layer_->children();
+  const LayerImplList& current_list = current_layer_->children();
   if (!current_list.empty()) {
-    current_layer_ = current_list[0].get();
+    current_layer_ = current_list[0];
     list_indices_.push_back(0);
     return *this;
   }
@@ -32,12 +32,12 @@ LayerListIterator& LayerListIterator::operator++() {
   for (LayerImpl* parent = current_layer_->parent(); parent;
        parent = parent->parent()) {
     // We now try and advance in some list of siblings.
-    const OwnedLayerImplList& sibling_list = parent->children();
+    const LayerImplList& sibling_list = parent->children();
 
     // case 2: Advance to a sibling.
     if (list_indices_.back() + 1 < sibling_list.size()) {
       ++list_indices_.back();
-      current_layer_ = sibling_list[list_indices_.back()].get();
+      current_layer_ = sibling_list[list_indices_.back()];
       return *this;
     }
 
@@ -73,8 +73,8 @@ LayerListIterator& LayerListReverseIterator::operator++() {
   // sibling over, and then descend to the rightmost descendant in that subtree.
   CHECK(current_layer_->parent());
   --list_indices_.back();
-  const OwnedLayerImplList& parent_list = current_layer_->parent()->children();
-  current_layer_ = parent_list[list_indices_.back()].get();
+  const LayerImplList& parent_list = current_layer_->parent()->children();
+  current_layer_ = parent_list[list_indices_.back()];
   DescendToRightmostInSubtree();
   return *this;
 }
@@ -83,12 +83,12 @@ void LayerListReverseIterator::DescendToRightmostInSubtree() {
   if (!current_layer_)
     return;
 
-  const OwnedLayerImplList& current_list = current_layer_->children();
+  const LayerImplList& current_list = current_layer_->children();
   if (current_list.empty())
     return;
 
   size_t last_index = current_list.size() - 1;
-  current_layer_ = current_list[last_index].get();
+  current_layer_ = current_list[last_index];
   list_indices_.push_back(last_index);
   DescendToRightmostInSubtree();
 }
diff --git a/cc/layers/layer_lists.h b/cc/layers/layer_lists.h
deleted file mode 100644
index 264d219a..0000000
--- a/cc/layers/layer_lists.h
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2013 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.
-
-#ifndef CC_LAYERS_LAYER_LISTS_H_
-#define CC_LAYERS_LAYER_LISTS_H_
-
-#include <vector>
-
-#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
-#include "cc/base/cc_export.h"
-
-namespace cc {
-class Layer;
-class LayerImpl;
-
-typedef std::vector<scoped_refptr<Layer>> LayerList;
-typedef std::vector<scoped_ptr<LayerImpl>> OwnedLayerImplList;
-typedef std::vector<LayerImpl*> LayerImplList;
-
-}  // namespace cc
-
-#endif  // CC_LAYERS_LAYER_LISTS_H_
diff --git a/cc/layers/layer_position_constraint_unittest.cc b/cc/layers/layer_position_constraint_unittest.cc
index 5cdef88..ee252f3 100644
--- a/cc/layers/layer_position_constraint_unittest.cc
+++ b/cc/layers/layer_position_constraint_unittest.cc
@@ -155,16 +155,14 @@ class LayerPositionConstraintTest : public testing::Test {
       SetScrollOffsetDelta(grand_child_impl_, gfx::Vector2dF());
     }
     root_impl_ = layer_tree_host_->CommitAndCreateLayerImplTree();
-    inner_viewport_container_layer_impl_ = root_impl_->children()[0].get();
-    scroll_layer_impl_ =
-        inner_viewport_container_layer_impl_->children()[0].get();
-    outer_viewport_container_layer_impl_ =
-        scroll_layer_impl_->children()[0].get();
+    inner_viewport_container_layer_impl_ = root_impl_->children()[0];
+    scroll_layer_impl_ = inner_viewport_container_layer_impl_->children()[0];
+    outer_viewport_container_layer_impl_ = scroll_layer_impl_->children()[0];
     child_transform_layer_impl_ =
-        outer_viewport_container_layer_impl_->children()[0].get();
-    child_impl_ = child_transform_layer_impl_->children()[0].get();
-    grand_child_impl_ = child_impl_->children()[0].get();
-    great_grand_child_impl_ = grand_child_impl_->children()[0].get();
+        outer_viewport_container_layer_impl_->children()[0];
+    child_impl_ = child_transform_layer_impl_->children()[0];
+    grand_child_impl_ = child_impl_->children()[0];
+    great_grand_child_impl_ = grand_child_impl_->children()[0];
   }
 
  protected:
@@ -577,8 +575,7 @@ TEST_F(LayerPositionConstraintTest,
   fixed_position_child->SetTransform(rotation_about_z);
 
   CommitAndUpdateImplPointers();
-  LayerImpl* fixed_position_child_impl =
-      great_grand_child_impl_->children()[0].get();
+  LayerImpl* fixed_position_child_impl = great_grand_child_impl_->children()[0];
 
   // Case 1: scroll delta of 0, 0
   SetScrollOffsetDelta(child_impl_, gfx::Vector2d(0, 0));
@@ -674,7 +671,7 @@ TEST_F(LayerPositionConstraintTest,
   // Case 4: Bottom-right fixed-position layer.
   fixed_position_child->SetPositionConstraint(fixed_to_bottom_right_);
   CommitAndUpdateImplPointers();
-  fixed_position_child_impl = great_grand_child_impl_->children()[0].get();
+  fixed_position_child_impl = great_grand_child_impl_->children()[0];
   SetScrollOffsetDelta(child_impl_, gfx::Vector2d(10, 30));
   SetFixedContainerSizeDelta(child_impl_, gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_impl_);
@@ -735,8 +732,7 @@ TEST_F(
   fixed_position_child->SetTransform(rotation_about_z);
 
   CommitAndUpdateImplPointers();
-  LayerImpl* fixed_position_child_impl =
-      great_grand_child_impl_->children()[0].get();
+  LayerImpl* fixed_position_child_impl = great_grand_child_impl_->children()[0];
 
   // Case 1: scroll delta of 0, 0
   SetScrollOffsetDelta(child_impl_, gfx::Vector2d(0, 0));
@@ -1055,7 +1051,7 @@ TEST_F(LayerPositionConstraintTest,
   LayerImpl* container1 = child_impl_;
   LayerImpl* fixed_to_container1 = grand_child_impl_;
   LayerImpl* container2 = great_grand_child_impl_;
-  LayerImpl* fixed_to_container2 = container2->children()[0].get();
+  LayerImpl* fixed_to_container2 = container2->children()[0];
 
   SetScrollOffsetDelta(container1, gfx::Vector2d(0, 15));
   container1->SetDrawsContent(true);
diff --git a/cc/layers/layer_unittest.cc b/cc/layers/layer_unittest.cc
index c403f1a..da644f5 100644
--- a/cc/layers/layer_unittest.cc
+++ b/cc/layers/layer_unittest.cc
@@ -1138,7 +1138,7 @@ TEST_F(LayerTest, AddAndRemoveChild) {
   EXPECT_SET_NEEDS_FULL_TREE_SYNC(1, parent->AddChild(child));
 
   ASSERT_EQ(1U, parent->children().size());
-  EXPECT_EQ(child.get(), parent->children()[0].get());
+  EXPECT_EQ(child.get(), parent->children()[0]);
   EXPECT_EQ(parent.get(), child->parent());
   EXPECT_EQ(parent.get(), child->RootLayer());
 
diff --git a/cc/layers/layer_utils_unittest.cc b/cc/layers/layer_utils_unittest.cc
index e915c41..771d5bd 100644
--- a/cc/layers/layer_utils_unittest.cc
+++ b/cc/layers/layer_utils_unittest.cc
@@ -32,12 +32,12 @@ class LayerUtilsGetAnimationBoundsTest : public testing::Test {
                    &shared_bitmap_manager_,
                    &task_graph_runner_),
         root_(CreateTwoForkTree(&host_impl_)),
-        parent1_(root_->children()[0].get()),
-        parent2_(root_->children()[1].get()),
-        child1_(parent1_->children()[0].get()),
-        child2_(parent2_->children()[0].get()),
-        grand_child_(child2_->children()[0].get()),
-        great_grand_child_(grand_child_->children()[0].get()) {
+        parent1_(root_->children()[0]),
+        parent2_(root_->children()[1]),
+        child1_(parent1_->children()[0]),
+        child2_(parent2_->children()[0]),
+        grand_child_(child2_->children()[0]),
+        great_grand_child_(grand_child_->children()[0]) {
     timeline_ =
         AnimationTimeline::Create(AnimationIdProvider::NextTimelineId());
     host_impl_.animation_host()->AddAnimationTimeline(timeline_);
diff --git a/cc/layers/picture_layer_impl_perftest.cc b/cc/layers/picture_layer_impl_perftest.cc
index feeb28f..2bf89e7 100644
--- a/cc/layers/picture_layer_impl_perftest.cc
+++ b/cc/layers/picture_layer_impl_perftest.cc
@@ -61,7 +61,7 @@ class PictureLayerImplPerfTest : public testing::Test {
         FakeDisplayListRasterSource::CreateFilled(layer_bounds);
     host_impl_.CreatePendingTree();
     LayerTreeImpl* pending_tree = host_impl_.pending_tree();
-    pending_tree->DetachLayerTree();
+    pending_tree->ClearLayers();
 
     scoped_ptr<FakePictureLayerImpl> pending_layer =
         FakePictureLayerImpl::CreateWithRasterSource(pending_tree, 7,
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index 2c9780e..a73e293 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -229,20 +229,22 @@ class PictureLayerImplTest : public testing::Test {
         host_impl_.active_tree()->device_scale_factor());
 
     // Steal from the recycled tree if possible.
-    scoped_ptr<LayerImpl> pending_root = pending_tree->DetachLayerTree();
+    LayerImpl* pending_root = pending_tree->root_layer();
     scoped_ptr<FakePictureLayerImpl> pending_layer;
     DCHECK(!pending_root || pending_root->id() == root_id_);
     if (!pending_root) {
-      pending_root = LayerImpl::Create(pending_tree, root_id_);
+      scoped_ptr<LayerImpl> new_pending_root =
+          LayerImpl::Create(pending_tree, root_id_);
       pending_layer = FakePictureLayerImpl::Create(pending_tree, id_);
       if (!tile_size.IsEmpty())
         pending_layer->set_fixed_tile_size(tile_size);
       pending_layer->SetDrawsContent(true);
-      pending_layer->SetScrollClipLayer(pending_root->id());
+      pending_layer->SetScrollClipLayer(new_pending_root->id());
+      pending_root = new_pending_root.get();
+      pending_tree->SetRootLayer(std::move(new_pending_root));
     } else {
       pending_layer.reset(static_cast<FakePictureLayerImpl*>(
-          pending_root->RemoveChild(pending_root->children()[0].get())
-              .release()));
+          pending_root->RemoveChild(pending_root->children()[0]).release()));
       if (!tile_size.IsEmpty())
         pending_layer->set_fixed_tile_size(tile_size);
     }
@@ -252,7 +254,6 @@ class PictureLayerImplTest : public testing::Test {
     pending_layer->SetRasterSourceOnPending(raster_source, invalidation);
 
     pending_root->AddChild(std::move(pending_layer));
-    pending_tree->SetRootLayer(std::move(pending_root));
     pending_tree->SetViewportLayersFromIds(
         Layer::INVALID_ID, pending_tree->root_layer()->id(), Layer::INVALID_ID,
         Layer::INVALID_ID);
@@ -3860,7 +3861,7 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
 
   // Partial occlusion.
   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 1));
-  LayerImpl* layer1 = pending_layer_->children()[0].get();
+  LayerImpl* layer1 = pending_layer_->children()[0];
   layer1->SetBounds(layer_bounds);
   layer1->SetDrawsContent(true);
   layer1->SetContentsOpaque(true);
@@ -3955,7 +3956,7 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
 
   // Partial occlusion.
   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 1));
-  LayerImpl* layer1 = pending_layer_->children()[0].get();
+  LayerImpl* layer1 = pending_layer_->children()[0];
   layer1->SetBounds(layer_bounds);
   layer1->SetDrawsContent(true);
   layer1->SetContentsOpaque(true);
@@ -4052,7 +4053,7 @@ TEST_F(OcclusionTrackingPictureLayerImplTest, OcclusionForDifferentScales) {
   ASSERT_TRUE(pending_layer_->CanHaveTilings());
 
   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 1));
-  LayerImpl* layer1 = pending_layer_->children()[0].get();
+  LayerImpl* layer1 = pending_layer_->children()[0];
   layer1->SetBounds(layer_bounds);
   layer1->SetDrawsContent(true);
   layer1->SetContentsOpaque(true);
@@ -4127,7 +4128,7 @@ TEST_F(OcclusionTrackingPictureLayerImplTest, DifferentOcclusionOnTrees) {
 
   // Partially occlude the active layer.
   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 2));
-  LayerImpl* layer1 = pending_layer_->children()[0].get();
+  LayerImpl* layer1 = pending_layer_->children()[0];
   layer1->SetBounds(layer_bounds);
   layer1->SetDrawsContent(true);
   layer1->SetContentsOpaque(true);
@@ -4220,7 +4221,7 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
 
   // Partially occlude the active layer.
   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 2));
-  LayerImpl* active_occluding_layer = pending_layer_->children()[0].get();
+  LayerImpl* active_occluding_layer = pending_layer_->children()[0];
   active_occluding_layer->SetBounds(layer_bounds);
   active_occluding_layer->SetDrawsContent(true);
   active_occluding_layer->SetContentsOpaque(true);
@@ -4235,7 +4236,7 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
 
   // Partially occlude the pending layer in a different way.
   pending_layer_->AddChild(LayerImpl::Create(host_impl_.pending_tree(), 3));
-  LayerImpl* pending_occluding_layer = pending_layer_->children()[0].get();
+  LayerImpl* pending_occluding_layer = pending_layer_->children()[0];
   pending_occluding_layer->SetBounds(layer_bounds);
   pending_occluding_layer->SetDrawsContent(true);
   pending_occluding_layer->SetContentsOpaque(true);
@@ -4369,7 +4370,7 @@ TEST_F(PictureLayerImplTest, PendingOrActiveTwinLayer) {
 
   // Make an empty pending tree.
   host_impl_.CreatePendingTree();
-  host_impl_.pending_tree()->DetachLayerTree();
+  host_impl_.pending_tree()->ClearLayers();
   EXPECT_FALSE(active_layer_->GetPendingOrActiveTwinLayer());
 }
 
diff --git a/cc/layers/render_surface_impl.h b/cc/layers/render_surface_impl.h
index 3abce59..de7a984 100644
--- a/cc/layers/render_surface_impl.h
+++ b/cc/layers/render_surface_impl.h
@@ -13,7 +13,7 @@
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/base/cc_export.h"
-#include "cc/layers/layer_lists.h"
+#include "cc/layers/layer_collections.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/trees/occlusion.h"
diff --git a/cc/layers/render_surface_impl_unittest.cc b/cc/layers/render_surface_impl_unittest.cc
index aa68c15..436eab5 100644
--- a/cc/layers/render_surface_impl_unittest.cc
+++ b/cc/layers/render_surface_impl_unittest.cc
@@ -100,7 +100,7 @@ TEST(RenderSurfaceLayerImplTest, AppendQuadsWithScaledMask) {
   impl.host_impl()->active_tree()->UpdateDrawProperties(false);
 
   LayerImpl* surface_raw =
-      impl.host_impl()->active_tree()->root_layer()->children()[0].get();
+      impl.host_impl()->active_tree()->root_layer()->children()[0];
   RenderSurfaceImpl* render_surface_impl = surface_raw->render_surface();
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData append_quads_data;
diff --git a/cc/layers/scrollbar_layer_unittest.cc b/cc/layers/scrollbar_layer_unittest.cc
index 7288882..0979b2f 100644
--- a/cc/layers/scrollbar_layer_unittest.cc
+++ b/cc/layers/scrollbar_layer_unittest.cc
@@ -151,7 +151,7 @@ TEST_F(ScrollbarLayerTest, ShouldScrollNonOverlayOnMainThread) {
       layer_tree_host_.get(), std::move(scrollbar), false, false, 0, 0);
   PaintedScrollbarLayerImpl* scrollbar_layer_impl =
       static_cast<PaintedScrollbarLayerImpl*>(
-          layer_impl_tree_root->children()[1].get());
+          layer_impl_tree_root->children()[1]);
   layer_impl_tree_root->layer_tree_impl()->BuildPropertyTreesForTesting();
   ScrollTree& scroll_tree =
       layer_impl_tree_root->layer_tree_impl()->property_trees()->scroll_tree;
@@ -173,7 +173,7 @@ TEST_F(ScrollbarLayerTest, ShouldScrollNonOverlayOnMainThread) {
   layer_impl_tree_root = LayerImplForScrollAreaAndScrollbar(
       layer_tree_host_.get(), std::move(scrollbar), false, false, 0, 0);
   scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>(
-      layer_impl_tree_root->children()[1].get());
+      layer_impl_tree_root->children()[1]);
   layer_impl_tree_root->layer_tree_impl()->BuildPropertyTreesForTesting();
   scroll_tree =
       layer_impl_tree_root->layer_tree_impl()->property_trees()->scroll_tree;
@@ -218,7 +218,7 @@ TEST_F(ScrollbarLayerTest, ScrollOffsetSynchronization) {
 
   ScrollbarLayerImplBase* cc_scrollbar_layer =
       static_cast<PaintedScrollbarLayerImpl*>(
-          layer_impl_tree_root->children()[1].get());
+          layer_impl_tree_root->children()[1]);
 
   EXPECT_EQ(10.f, cc_scrollbar_layer->current_pos());
   EXPECT_EQ(30, cc_scrollbar_layer->scroll_layer_length() -
@@ -239,7 +239,7 @@ TEST_F(ScrollbarLayerTest, ScrollOffsetSynchronization) {
   EXPECT_EQ(300, cc_scrollbar_layer->scroll_layer_length() -
                      cc_scrollbar_layer->clip_layer_length());
 
-  LayerImpl* scroll_layer_impl = layer_impl_tree_root->children()[0].get();
+  LayerImpl* scroll_layer_impl = layer_impl_tree_root->children()[0];
   scroll_layer_impl->ScrollBy(gfx::Vector2d(12, 34));
 
   EXPECT_EQ(112.f, cc_scrollbar_layer->current_pos());
@@ -252,9 +252,9 @@ TEST_F(ScrollbarLayerTest, ScrollOffsetSynchronization) {
     scrollbar_layer->UpdateInternalContentScale();                           \
     scrollbar_layer->UpdateThumbAndTrackGeometry();                          \
     root_clip_layer_impl = layer_tree_host_->CommitAndCreateLayerImplTree(); \
-    root_layer_impl = root_clip_layer_impl->children()[0].get();             \
+    root_layer_impl = root_clip_layer_impl->children()[0];                   \
     scrollbar_layer_impl = static_cast<PaintedScrollbarLayerImpl*>(          \
-        root_layer_impl->children()[1].get());                               \
+        root_layer_impl->children()[1]);                                     \
   } while (false)
 
 TEST_F(ScrollbarLayerTest, UpdatePropertiesOfScrollBarWhenThumbRemoved) {
@@ -386,7 +386,7 @@ TEST_F(ScrollbarLayerTest, SolidColorDrawQuads) {
       kThumbThickness, kTrackStart);
   ScrollbarLayerImplBase* scrollbar_layer_impl =
       static_cast<SolidColorScrollbarLayerImpl*>(
-          layer_impl_tree_root->children()[1].get());
+          layer_impl_tree_root->children()[1]);
   scrollbar_layer_impl->SetBounds(gfx::Size(kTrackLength, kThumbThickness));
   scrollbar_layer_impl->SetCurrentPos(10.f);
   scrollbar_layer_impl->SetClipLayerLength(200 / 3.f);
@@ -467,10 +467,10 @@ TEST_F(ScrollbarLayerTest, LayerDrivenSolidColorDrawQuads) {
 
   LayerImpl* layer_impl_tree_root =
       layer_tree_host_->CommitAndCreateLayerImplTree();
-  LayerImpl* scroll_layer_impl = layer_impl_tree_root->children()[0].get();
+  LayerImpl* scroll_layer_impl = layer_impl_tree_root->children()[0];
 
-  auto* scrollbar_layer_impl = static_cast<ScrollbarLayerImplBase*>(
-      scroll_layer_impl->children()[1].get());
+  auto* scrollbar_layer_impl =
+      static_cast<ScrollbarLayerImplBase*>(scroll_layer_impl->children()[1]);
 
   scroll_layer_impl->ScrollBy(gfx::Vector2dF(4.f, 0.f));
 
diff --git a/cc/test/fake_layer_tree_host.cc b/cc/test/fake_layer_tree_host.cc
index b0af310..84c2175 100644
--- a/cc/test/fake_layer_tree_host.cc
+++ b/cc/test/fake_layer_tree_host.cc
@@ -81,15 +81,11 @@ const RendererCapabilities& FakeLayerTreeHost::GetRendererCapabilities() const {
 void FakeLayerTreeHost::SetNeedsCommit() { needs_commit_ = true; }
 
 LayerImpl* FakeLayerTreeHost::CommitAndCreateLayerImplTree() {
-  scoped_ptr<LayerImpl> old_root_layer_impl = active_tree()->DetachLayerTree();
-
-  scoped_ptr<LayerImpl> layer_impl = TreeSynchronizer::SynchronizeTrees(
-      root_layer(), std::move(old_root_layer_impl), active_tree());
+  TreeSynchronizer::SynchronizeTrees(root_layer(), active_tree());
   active_tree()->SetPropertyTrees(*property_trees());
   TreeSynchronizer::PushLayerProperties(root_layer()->layer_tree_host(),
                                         active_tree());
 
-  active_tree()->SetRootLayer(std::move(layer_impl));
   active_tree()->UpdatePropertyTreeScrollOffset(property_trees());
 
   if (page_scale_layer() && inner_viewport_scroll_layer()) {
@@ -106,15 +102,10 @@ LayerImpl* FakeLayerTreeHost::CommitAndCreateLayerImplTree() {
 }
 
 LayerImpl* FakeLayerTreeHost::CommitAndCreatePendingTree() {
-  scoped_ptr<LayerImpl> old_root_layer_impl = pending_tree()->DetachLayerTree();
-
-  scoped_ptr<LayerImpl> layer_impl = TreeSynchronizer::SynchronizeTrees(
-      root_layer(), std::move(old_root_layer_impl), pending_tree());
+  TreeSynchronizer::SynchronizeTrees(root_layer(), pending_tree());
   pending_tree()->SetPropertyTrees(*property_trees());
   TreeSynchronizer::PushLayerProperties(root_layer()->layer_tree_host(),
                                         pending_tree());
-
-  pending_tree()->SetRootLayer(std::move(layer_impl));
   pending_tree()->UpdatePropertyTreeScrollOffset(property_trees());
   return pending_tree()->root_layer();
 }
diff --git a/cc/test/fake_layer_tree_host_impl.cc b/cc/test/fake_layer_tree_host_impl.cc
index 17963c3..5d3b510 100644
--- a/cc/test/fake_layer_tree_host_impl.cc
+++ b/cc/test/fake_layer_tree_host_impl.cc
@@ -86,7 +86,7 @@ int FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(LayerImpl* layer) {
   int num_children_that_draw_content = 0;
   for (size_t i = 0; i < layer->children().size(); ++i) {
     num_children_that_draw_content +=
-        RecursiveUpdateNumChildren(layer->children()[i].get());
+        RecursiveUpdateNumChildren(layer->children()[i]);
   }
   layer->SetNumDescendantsThatDrawContent(num_children_that_draw_content);
   return num_children_that_draw_content + (layer->DrawsContent() ? 1 : 0);
diff --git a/cc/test/layer_tree_host_common_test.h b/cc/test/layer_tree_host_common_test.h
index ecfb445..ee08639 100644
--- a/cc/test/layer_tree_host_common_test.h
+++ b/cc/test/layer_tree_host_common_test.h
@@ -9,7 +9,7 @@
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
-#include "cc/layers/layer_lists.h"
+#include "cc/layers/layer_collections.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/layer_test_common.h"
 #include "cc/test/test_task_graph_runner.h"
diff --git a/cc/test/layer_tree_json_parser_unittest.cc b/cc/test/layer_tree_json_parser_unittest.cc
index 7fcacc2..7cd1a8b 100644
--- a/cc/test/layer_tree_json_parser_unittest.cc
+++ b/cc/test/layer_tree_json_parser_unittest.cc
@@ -47,7 +47,7 @@ bool LayerTreesMatch(LayerImpl* const layer_impl,
 
   for (size_t i = 0; i < layer_impl->children().size(); ++i) {
     RETURN_IF_EXPECTATION_FAILS(EXPECT_TRUE(LayerTreesMatch(
-        layer_impl->children()[i].get(), layer->children()[i].get())));
+        layer_impl->children()[i], layer->children()[i].get())));
   }
 
   return true;
diff --git a/cc/tiles/tile_manager_perftest.cc b/cc/tiles/tile_manager_perftest.cc
index d10c4cb..7529e36 100644
--- a/cc/tiles/tile_manager_perftest.cc
+++ b/cc/tiles/tile_manager_perftest.cc
@@ -164,7 +164,7 @@ class TileManagerPerfTest : public testing::Test {
     host_impl_.CreatePendingTree();
     LayerTreeImpl* pending_tree = host_impl_.pending_tree();
     // Clear recycled tree.
-    pending_tree->DetachLayerTree();
+    pending_tree->ClearLayers();
 
     scoped_ptr<FakePictureLayerImpl> pending_layer =
         FakePictureLayerImpl::CreateWithRasterSource(pending_tree, id_,
diff --git a/cc/tiles/tile_manager_unittest.cc b/cc/tiles/tile_manager_unittest.cc
index f1659a0..5317081 100644
--- a/cc/tiles/tile_manager_unittest.cc
+++ b/cc/tiles/tile_manager_unittest.cc
@@ -126,23 +126,24 @@ class TileManagerTilePriorityQueueTest : public testing::Test {
     LayerTreeImpl* pending_tree = host_impl_.pending_tree();
 
     // Steal from the recycled tree.
-    scoped_ptr<LayerImpl> old_pending_root = pending_tree->DetachLayerTree();
+    LayerImpl* old_pending_root = pending_tree->root_layer();
     DCHECK(!old_pending_root || old_pending_root->id() == id_);
 
-    scoped_ptr<FakePictureLayerImpl> pending_layer;
+    FakePictureLayerImpl* pending_layer = nullptr;
     if (old_pending_root) {
-      pending_layer.reset(
-          static_cast<FakePictureLayerImpl*>(old_pending_root.release()));
+      pending_layer = static_cast<FakePictureLayerImpl*>(old_pending_root);
       pending_layer->SetRasterSourceOnPending(raster_source, Region());
     } else {
-      pending_layer = FakePictureLayerImpl::CreateWithRasterSource(
-          pending_tree, id_, raster_source);
+      scoped_ptr<FakePictureLayerImpl> new_root =
+          FakePictureLayerImpl::CreateWithRasterSource(pending_tree, id_,
+                                                       raster_source);
+      pending_layer = new_root.get();
+      pending_tree->SetRootLayer(std::move(new_root));
       pending_layer->SetDrawsContent(true);
       pending_layer->SetHasRenderSurface(true);
     }
     // The bounds() just mirror the raster source size.
     pending_layer->SetBounds(pending_layer->raster_source()->GetSize());
-    pending_tree->SetRootLayer(std::move(pending_layer));
 
     pending_layer_ = static_cast<FakePictureLayerImpl*>(
         host_impl_.pending_tree()->LayerById(id_));
@@ -907,7 +908,7 @@ TEST_F(TileManagerTilePriorityQueueTest,
   pending_layer_->AddChild(std::move(pending_child));
 
   FakePictureLayerImpl* pending_child_layer =
-      static_cast<FakePictureLayerImpl*>(pending_layer_->children()[0].get());
+      static_cast<FakePictureLayerImpl*>(pending_layer_->children()[0]);
   pending_child_layer->SetDrawsContent(true);
 
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
@@ -920,7 +921,7 @@ TEST_F(TileManagerTilePriorityQueueTest,
   SetupPendingTree(pending_raster_source);
 
   FakePictureLayerImpl* active_child_layer =
-      static_cast<FakePictureLayerImpl*>(active_layer_->children()[0].get());
+      static_cast<FakePictureLayerImpl*>(active_layer_->children()[0]);
 
   std::set<Tile*> all_tiles;
   size_t tile_count = 0;
@@ -1622,22 +1623,24 @@ class TileManagerTest : public testing::Test {
     LayerTreeImpl* pending_tree = host_impl_->pending_tree();
 
     // Steal from the recycled tree.
-    scoped_ptr<LayerImpl> old_pending_root = pending_tree->DetachLayerTree();
-    scoped_ptr<FakePictureLayerImpl> pending_layer;
+    LayerImpl* old_pending_root = pending_tree->root_layer();
+    FakePictureLayerImpl* pending_layer = nullptr;
     if (old_pending_root) {
-      pending_layer.reset(
-          static_cast<FakePictureLayerImpl*>(old_pending_root.release()));
+      pending_layer = static_cast<FakePictureLayerImpl*>(old_pending_root);
       pending_layer->SetRasterSourceOnPending(raster_source, Region());
     } else {
       int id = 7;
-      pending_layer = FakePictureLayerImpl::CreateWithRasterSource(
-          pending_tree, id, raster_source);
+      scoped_ptr<FakePictureLayerImpl> new_root =
+          FakePictureLayerImpl::CreateWithRasterSource(pending_tree, id,
+                                                       raster_source);
+      pending_layer = new_root.get();
       pending_layer->SetDrawsContent(true);
       pending_layer->SetHasRenderSurface(true);
+      pending_tree->SetRootLayer(std::move(new_root));
     }
+
     // The bounds() just mirror the raster source size.
     pending_layer->SetBounds(pending_layer->raster_source()->GetSize());
-    pending_tree->SetRootLayer(std::move(pending_layer));
 
     // Add tilings/tiles for the layer.
     bool update_lcd_text = false;
diff --git a/cc/trees/damage_tracker.h b/cc/trees/damage_tracker.h
index 6550db1..bded662 100644
--- a/cc/trees/damage_tracker.h
+++ b/cc/trees/damage_tracker.h
@@ -9,7 +9,7 @@
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/base/cc_export.h"
-#include "cc/layers/layer_lists.h"
+#include "cc/layers/layer_collections.h"
 #include "ui/gfx/geometry/rect.h"
 
 class SkImageFilter;
diff --git a/cc/trees/damage_tracker_unittest.cc b/cc/trees/damage_tracker_unittest.cc
index abb0369..4dd597d 100644
--- a/cc/trees/damage_tracker_unittest.cc
+++ b/cc/trees/damage_tracker_unittest.cc
@@ -48,7 +48,7 @@ void ClearDamageForAllSurfaces(LayerImpl* layer) {
 
   // Recursively clear damage for any existing surface.
   for (size_t i = 0; i < layer->children().size(); ++i)
-    ClearDamageForAllSurfaces(layer->children()[i].get());
+    ClearDamageForAllSurfaces(layer->children()[i]);
 }
 
 void EmulateDrawingOneFrame(LayerImpl* root) {
@@ -88,7 +88,7 @@ class DamageTrackerTest : public testing::Test {
                    &task_graph_runner_) {}
 
   LayerImpl* CreateTestTreeWithOneSurface() {
-    host_impl_.active_tree()->DetachLayerTree();
+    host_impl_.active_tree()->ClearLayers();
     scoped_ptr<LayerImpl> root =
             LayerImpl::Create(host_impl_.active_tree(), 1);
     scoped_ptr<LayerImpl> child =
@@ -113,7 +113,7 @@ class DamageTrackerTest : public testing::Test {
     // child1. Additionally, the root has a second child layer, and child1 has
     // two children of its own.
 
-    host_impl_.active_tree()->DetachLayerTree();
+    host_impl_.active_tree()->ClearLayers();
     scoped_ptr<LayerImpl> root =
             LayerImpl::Create(host_impl_.active_tree(), 1);
     scoped_ptr<LayerImpl> child1 =
@@ -210,8 +210,8 @@ TEST_F(DamageTrackerTest, SanityCheckTestTreeWithTwoSurfaces) {
 
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
 
-  LayerImpl* child1 = root->children()[0].get();
-  LayerImpl* child2 = root->children()[1].get();
+  LayerImpl* child1 = root->children()[0];
+  LayerImpl* child2 = root->children()[1];
   gfx::Rect child_damage_rect =
       child1->render_surface()->damage_tracker()->current_damage_rect();
   gfx::Rect root_damage_rect =
@@ -231,7 +231,7 @@ TEST_F(DamageTrackerTest, SanityCheckTestTreeWithTwoSurfaces) {
 
 TEST_F(DamageTrackerTest, VerifyDamageForUpdateRects) {
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
-  LayerImpl* child = root->children()[0].get();
+  LayerImpl* child = root->children()[0];
 
   // CASE 1: Setting the update rect should cause the corresponding damage to
   //         the surface.
@@ -274,7 +274,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForUpdateRects) {
 
 TEST_F(DamageTrackerTest, VerifyDamageForLayerDamageRects) {
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
-  LayerImpl* child = root->children()[0].get();
+  LayerImpl* child = root->children()[0];
 
   // CASE 1: Adding the layer damage rect should cause the corresponding damage
   // to the surface.
@@ -330,7 +330,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForLayerDamageRects) {
 
 TEST_F(DamageTrackerTest, VerifyDamageForLayerUpdateAndDamageRects) {
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
-  LayerImpl* child = root->children()[0].get();
+  LayerImpl* child = root->children()[0];
 
   // CASE 1: Adding the layer damage rect and update rect should cause the
   // corresponding damage to the surface.
@@ -375,7 +375,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForLayerUpdateAndDamageRects) {
 
 TEST_F(DamageTrackerTest, VerifyDamageForPropertyChanges) {
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
-  LayerImpl* child = root->children()[0].get();
+  LayerImpl* child = root->children()[0];
 
   // CASE 1: The layer's property changed flag takes priority over update rect.
   //
@@ -427,7 +427,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForTransformedLayer) {
   // transformed layer.
 
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
-  LayerImpl* child = root->children()[0].get();
+  LayerImpl* child = root->children()[0];
   child->SetForceRenderSurface(true);
 
   gfx::Transform rotation;
@@ -480,7 +480,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForPerspectiveClippedLayer) {
   //
 
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
-  LayerImpl* child = root->children()[0].get();
+  LayerImpl* child = root->children()[0];
 
   gfx::Transform transform;
   transform.Translate3d(500.0, 500.0, 0.0);
@@ -521,8 +521,8 @@ TEST_F(DamageTrackerTest, VerifyDamageForPerspectiveClippedLayer) {
 
 TEST_F(DamageTrackerTest, VerifyDamageForBlurredSurface) {
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
-  LayerImpl* surface = root->children()[0].get();
-  LayerImpl* child = surface->children()[0].get();
+  LayerImpl* surface = root->children()[0];
+  LayerImpl* child = surface->children()[0];
 
   FilterOperations filters;
   filters.Append(FilterOperation::CreateBlurFilter(5.f));
@@ -557,7 +557,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForBlurredSurface) {
 
 TEST_F(DamageTrackerTest, VerifyDamageForImageFilter) {
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
-  LayerImpl* child = root->children()[0].get();
+  LayerImpl* child = root->children()[0];
   gfx::Rect root_damage_rect, child_damage_rect;
 
   // Allow us to set damage on child too.
@@ -612,8 +612,8 @@ TEST_F(DamageTrackerTest, VerifyDamageForImageFilter) {
 
 TEST_F(DamageTrackerTest, VerifyDamageForBackgroundBlurredChild) {
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
-  LayerImpl* child1 = root->children()[0].get();
-  LayerImpl* child2 = root->children()[1].get();
+  LayerImpl* child1 = root->children()[0];
+  LayerImpl* child2 = root->children()[1];
 
   // Allow us to set damage on child1 too.
   child1->SetDrawsContent(true);
@@ -746,7 +746,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForBackgroundBlurredChild) {
 
 TEST_F(DamageTrackerTest, VerifyDamageForAddingAndRemovingLayer) {
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
-  LayerImpl* child1 = root->children()[0].get();
+  LayerImpl* child1 = root->children()[0];
 
   // CASE 1: Adding a new layer should cause the appropriate damage.
   //
@@ -832,7 +832,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForNewUnchangedLayer) {
 
 TEST_F(DamageTrackerTest, VerifyDamageForMultipleLayers) {
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
-  LayerImpl* child1 = root->children()[0].get();
+  LayerImpl* child1 = root->children()[0];
 
   // In this test we don't want the above tree manipulation to be considered
   // part of the same frame.
@@ -845,7 +845,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForMultipleLayers) {
     child2->SetDrawsContent(true);
     root->AddChild(std::move(child2));
   }
-  LayerImpl* child2 = root->children()[1].get();
+  LayerImpl* child2 = root->children()[1];
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
 
@@ -865,9 +865,9 @@ TEST_F(DamageTrackerTest, VerifyDamageForMultipleLayers) {
 
 TEST_F(DamageTrackerTest, VerifyDamageForNestedSurfaces) {
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
-  LayerImpl* child1 = root->children()[0].get();
-  LayerImpl* child2 = root->children()[1].get();
-  LayerImpl* grand_child1 = root->children()[0]->children()[0].get();
+  LayerImpl* child1 = root->children()[0];
+  LayerImpl* child2 = root->children()[1];
+  LayerImpl* grand_child1 = root->children()[0]->children()[0];
   child2->SetForceRenderSurface(true);
   grand_child1->SetForceRenderSurface(true);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
@@ -915,8 +915,8 @@ TEST_F(DamageTrackerTest, VerifyDamageForSurfaceChangeFromDescendantLayer) {
   // entire surface should be marked dirty.
 
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
-  LayerImpl* child1 = root->children()[0].get();
-  LayerImpl* grand_child1 = root->children()[0]->children()[0].get();
+  LayerImpl* child1 = root->children()[0];
+  LayerImpl* grand_child1 = root->children()[0]->children()[0];
   gfx::Rect child_damage_rect;
   gfx::Rect root_damage_rect;
 
@@ -954,9 +954,9 @@ TEST_F(DamageTrackerTest, VerifyDamageForSurfaceChangeFromAncestorLayer) {
   // transforming it, while the root surface would be damaged appropriately.
 
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
-  LayerImpl* child1 = root->children()[0].get();
-  LayerImpl* grand_child1 = child1->children()[0].get();
-  LayerImpl* grand_child2 = child1->children()[1].get();
+  LayerImpl* child1 = root->children()[0];
+  LayerImpl* grand_child1 = child1->children()[0];
+  LayerImpl* grand_child2 = child1->children()[1];
   gfx::Rect child_damage_rect;
   gfx::Rect root_damage_rect;
 
@@ -986,7 +986,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForSurfaceChangeFromAncestorLayer) {
 
 TEST_F(DamageTrackerTest, VerifyDamageForAddingAndRemovingRenderSurfaces) {
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
-  LayerImpl* child1 = root->children()[0].get();
+  LayerImpl* child1 = root->children()[0];
   gfx::Rect child_damage_rect;
   gfx::Rect root_damage_rect;
 
@@ -1042,7 +1042,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForAddingAndRemovingRenderSurfaces) {
 
 TEST_F(DamageTrackerTest, VerifyNoDamageWhenNothingChanged) {
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
-  LayerImpl* child1 = root->children()[0].get();
+  LayerImpl* child1 = root->children()[0];
   gfx::Rect child_damage_rect;
   gfx::Rect root_damage_rect;
 
@@ -1074,7 +1074,7 @@ TEST_F(DamageTrackerTest, VerifyNoDamageWhenNothingChanged) {
 
 TEST_F(DamageTrackerTest, VerifyNoDamageForUpdateRectThatDoesNotDrawContent) {
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
-  LayerImpl* child1 = root->children()[0].get();
+  LayerImpl* child1 = root->children()[0];
   gfx::Rect child_damage_rect;
   gfx::Rect root_damage_rect;
 
@@ -1094,9 +1094,9 @@ TEST_F(DamageTrackerTest, VerifyNoDamageForUpdateRectThatDoesNotDrawContent) {
 
 TEST_F(DamageTrackerTest, VerifyDamageForReplica) {
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
-  LayerImpl* child1 = root->children()[0].get();
-  LayerImpl* grand_child1 = child1->children()[0].get();
-  LayerImpl* grand_child2 = child1->children()[1].get();
+  LayerImpl* child1 = root->children()[0];
+  LayerImpl* grand_child1 = child1->children()[0];
+  LayerImpl* grand_child2 = child1->children()[1];
 
   // Damage on a surface that has a reflection should cause the target surface
   // to receive the surface's damage and the surface's reflected damage.
@@ -1203,7 +1203,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForReplica) {
 
 TEST_F(DamageTrackerTest, VerifyDamageForMask) {
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
-  LayerImpl* child = root->children()[0].get();
+  LayerImpl* child = root->children()[0];
 
   // In the current implementation of the damage tracker, changes to mask
   // layers should damage the entire corresponding surface.
@@ -1296,8 +1296,8 @@ TEST_F(DamageTrackerTest, VerifyDamageForMask) {
 
 TEST_F(DamageTrackerTest, VerifyDamageForReplicaMask) {
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
-  LayerImpl* child1 = root->children()[0].get();
-  LayerImpl* grand_child1 = child1->children()[0].get();
+  LayerImpl* child1 = root->children()[0];
+  LayerImpl* grand_child1 = child1->children()[0];
 
   // Changes to a replica's mask should not damage the original surface,
   // because it is not masked. But it does damage the ancestor target surface.
@@ -1368,8 +1368,8 @@ TEST_F(DamageTrackerTest, VerifyDamageForReplicaMask) {
 
 TEST_F(DamageTrackerTest, VerifyDamageForReplicaMaskWithTransformOrigin) {
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
-  LayerImpl* child1 = root->children()[0].get();
-  LayerImpl* grand_child1 = child1->children()[0].get();
+  LayerImpl* child1 = root->children()[0];
+  LayerImpl* grand_child1 = child1->children()[0];
 
   // Verify that the correct replica_origin_transform is used for the
   // replica_mask.
@@ -1429,7 +1429,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForReplicaMaskWithTransformOrigin) {
 
 TEST_F(DamageTrackerTest, DamageWhenAddedExternally) {
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
-  LayerImpl* child = root->children()[0].get();
+  LayerImpl* child = root->children()[0];
 
   // Case 1: This test ensures that when the tracker is given damage, that
   //         it is included with any other partial damage.
@@ -1490,7 +1490,7 @@ TEST_F(DamageTrackerTest, VerifyDamageAccumulatesUntilReset) {
   // If damage is not cleared, it should accumulate.
 
   LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
-  LayerImpl* child = root->children()[0].get();
+  LayerImpl* child = root->children()[0];
 
   ClearDamageForAllSurfaces(root);
   child->SetUpdateRect(gfx::Rect(10.f, 11.f, 1.f, 2.f));
@@ -1537,7 +1537,7 @@ TEST_F(DamageTrackerTest, HugeDamageRect) {
 
   for (int i = 0; i < kRange; ++i) {
     LayerImpl* root = CreateTestTreeWithOneSurface();
-    LayerImpl* child = root->children()[0].get();
+    LayerImpl* child = root->children()[0];
 
     gfx::Transform transform;
     transform.Translate(-kBigNumber, -kBigNumber);
diff --git a/cc/trees/draw_property_utils.h b/cc/trees/draw_property_utils.h
index 70bd8a0..913234a 100644
--- a/cc/trees/draw_property_utils.h
+++ b/cc/trees/draw_property_utils.h
@@ -6,7 +6,7 @@
 #define CC_TREES_DRAW_PROPERTY_UTILS_H_
 
 #include "cc/base/cc_export.h"
-#include "cc/layers/layer_lists.h"
+#include "cc/layers/layer_collections.h"
 
 namespace gfx {
 class Rect;
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index a39d8b6..ced57c2 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -371,10 +371,9 @@ void LayerTreeHost::FinishCommitOnImplThread(LayerTreeHostImpl* host_impl) {
 
   sync_tree->set_source_frame_number(source_frame_number());
 
-  if (needs_full_tree_sync_) {
-    sync_tree->SetRootLayer(TreeSynchronizer::SynchronizeTrees(
-        root_layer(), sync_tree->DetachLayerTree(), sync_tree));
-  }
+  if (needs_full_tree_sync_)
+    TreeSynchronizer::SynchronizeTrees(root_layer(), sync_tree);
+
   sync_tree->set_needs_full_tree_sync(needs_full_tree_sync_);
   needs_full_tree_sync_ = false;
 
diff --git a/cc/trees/layer_tree_host.h b/cc/trees/layer_tree_host.h
index c82e9f6..ffb597b 100644
--- a/cc/trees/layer_tree_host.h
+++ b/cc/trees/layer_tree_host.h
@@ -30,7 +30,7 @@
 #include "cc/input/layer_selection_bound.h"
 #include "cc/input/scrollbar.h"
 #include "cc/input/top_controls_state.h"
-#include "cc/layers/layer_lists.h"
+#include "cc/layers/layer_collections.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/renderer_capabilities.h"
 #include "cc/output/swap_promise.h"
diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc
index 83c9c75..77b327b 100644
--- a/cc/trees/layer_tree_host_common.cc
+++ b/cc/trees/layer_tree_host_common.cc
@@ -824,23 +824,23 @@ void CalculateRenderSurfaceLayerList(
   if (render_to_separate_surface)
     layer->render_surface()->SetAccumulatedContentRect(gfx::Rect());
 
-  for (const auto& child_layer : layer->children()) {
+  for (auto* child_layer : layer->children()) {
     CalculateRenderSurfaceLayerList(
-        child_layer.get(), property_trees, render_surface_layer_list,
-        descendants, nearest_occlusion_immune_ancestor, layer_is_drawn,
+        child_layer, property_trees, render_surface_layer_list, descendants,
+        nearest_occlusion_immune_ancestor, layer_is_drawn,
         can_render_to_separate_surface, current_render_surface_layer_list_id,
         max_texture_size);
 
     // If the child is its own render target, then it has a render surface.
-    if (child_layer->render_target() == child_layer.get() &&
+    if (child_layer->render_target() == child_layer &&
         !child_layer->render_surface()->layer_list().empty() &&
         !child_layer->render_surface()->content_rect().IsEmpty()) {
       // This child will contribute its render surface, which means
       // we need to mark just the mask layer (and replica mask layer)
       // with the id.
       MarkMasksWithRenderSurfaceLayerListId(
-          child_layer.get(), current_render_surface_layer_list_id);
-      descendants->push_back(child_layer.get());
+          child_layer, current_render_surface_layer_list_id);
+      descendants->push_back(child_layer);
     }
 
     if (child_layer->layer_or_descendant_is_drawn()) {
diff --git a/cc/trees/layer_tree_host_common.h b/cc/trees/layer_tree_host_common.h
index c2e7cdc..85df71f 100644
--- a/cc/trees/layer_tree_host_common.h
+++ b/cc/trees/layer_tree_host_common.h
@@ -14,7 +14,7 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "cc/base/cc_export.h"
-#include "cc/layers/layer_lists.h"
+#include "cc/layers/layer_collections.h"
 #include "cc/trees/property_tree.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/vector2d.h"
@@ -145,11 +145,6 @@ class CC_EXPORT LayerTreeHostCommon {
     return layers[index].get();
   }
 
-  static LayerImpl* get_layer_as_raw_ptr(const OwnedLayerImplList& layers,
-                                         size_t index) {
-    return layers[index].get();
-  }
-
   static LayerImpl* get_layer_as_raw_ptr(const LayerImplList& layers,
                                          size_t index) {
     return layers[index];
diff --git a/cc/trees/layer_tree_host_common_perftest.cc b/cc/trees/layer_tree_host_common_perftest.cc
index b4717fa..3b61768 100644
--- a/cc/trees/layer_tree_host_common_perftest.cc
+++ b/cc/trees/layer_tree_host_common_perftest.cc
@@ -184,7 +184,7 @@ class BspTreePerfTest : public CalcDrawPropsTest {
     }
 
     for (size_t i = 0; i < layer->children().size(); i++) {
-      BuildLayerImplList(layer->children()[i].get(), list);
+      BuildLayerImplList(layer->children()[i], list);
     }
   }
 
diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc
index 69821a3..24352bc 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc
@@ -3577,7 +3577,7 @@ TEST_F(LayerTreeHostCommonTest,
   host_impl.active_tree()->UpdateDrawProperties(update_lcd_text);
 
   LayerImpl* grand_child_ptr =
-      host_impl.active_tree()->root_layer()->children()[0]->children()[0].get();
+      host_impl.active_tree()->root_layer()->children()[0]->children()[0];
 
   // Though all layers have invertible transforms, matrix multiplication using
   // floating-point math makes the draw transform uninvertible.
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index bf706b6..7e7adfe 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -1197,17 +1197,17 @@ void LayerTreeHostImpl::BlockNotifyReadyToActivateForTesting(bool block) {
 
 void LayerTreeHostImpl::ResetTreesForTesting() {
   if (active_tree_)
-    active_tree_->DetachLayerTree();
+    active_tree_->ClearLayers();
   active_tree_ =
       LayerTreeImpl::create(this, active_tree()->page_scale_factor(),
                             active_tree()->top_controls_shown_ratio(),
                             active_tree()->elastic_overscroll());
   active_tree_->property_trees()->is_active = true;
   if (pending_tree_)
-    pending_tree_->DetachLayerTree();
+    pending_tree_->ClearLayers();
   pending_tree_ = nullptr;
   if (recycle_tree_)
-    recycle_tree_->DetachLayerTree();
+    recycle_tree_->ClearLayers();
   recycle_tree_ = nullptr;
 }
 
@@ -1957,11 +1957,10 @@ void LayerTreeHostImpl::ActivateSyncTree() {
     pending_tree_->ProcessUIResourceRequestQueue();
 
     if (pending_tree_->needs_full_tree_sync()) {
-      active_tree_->SetRootLayer(
-          TreeSynchronizer::SynchronizeTrees(pending_tree_->root_layer(),
-                                             active_tree_->DetachLayerTree(),
-                                             active_tree_.get()));
+      TreeSynchronizer::SynchronizeTrees(pending_tree_->root_layer(),
+                                         active_tree_.get());
     }
+
     // We need to preserve the damage status of property trees on active tree.
     // We do this by pushing the damage status from active tree property trees
     // to pending tree property trees.
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index 026294b..f9ad198 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -22,7 +22,7 @@
 #include "cc/input/input_handler.h"
 #include "cc/input/scrollbar_animation_controller.h"
 #include "cc/input/top_controls_manager_client.h"
-#include "cc/layers/layer_lists.h"
+#include "cc/layers/layer_collections.h"
 #include "cc/layers/render_pass_sink.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/output/managed_memory_policy.h"
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 9c968bd..d81c3a8 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -235,7 +235,7 @@ class LayerTreeHostImplTest : public testing::Test,
   static void ExpectClearedScrollDeltasRecursive(LayerImpl* layer) {
     ASSERT_EQ(ScrollDelta(layer), gfx::Vector2d());
     for (size_t i = 0; i < layer->children().size(); ++i)
-      ExpectClearedScrollDeltasRecursive(layer->children()[i].get());
+      ExpectClearedScrollDeltasRecursive(layer->children()[i]);
   }
 
   static ::testing::AssertionResult ScrollInfoContains(
@@ -367,7 +367,7 @@ class LayerTreeHostImplTest : public testing::Test,
     CreateScrollAndContentsLayers(host_impl_->active_tree(), content_size);
 
     LayerImpl* content_layer =
-        host_impl_->OuterViewportScrollLayer()->children().back().get();
+        host_impl_->OuterViewportScrollLayer()->children().back();
     content_layer->SetBounds(content_size);
     host_impl_->OuterViewportScrollLayer()->SetBounds(content_size);
 
@@ -628,8 +628,7 @@ TEST_F(LayerTreeHostImplTest, ScrollDeltaRepeatedScrolls) {
     root_layer->ScrollBy(scroll_delta);
   }
 
-  LayerImpl* root =
-      host_impl_->active_tree()->root_layer()->children()[0].get();
+  LayerImpl* root = host_impl_->active_tree()->root_layer()->children()[0];
 
   scoped_ptr<ScrollAndScaleSet> scroll_info;
 
@@ -731,7 +730,7 @@ TEST_F(LayerTreeHostImplTest, ReplaceTreeWhileScrolling) {
             host_impl_->ScrollBegin(BeginState(gfx::Point()).get(),
                                     InputHandler::WHEEL)
                 .thread);
-  host_impl_->active_tree()->DetachLayerTree();
+  host_impl_->active_tree()->ClearLayers();
 
   scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 100));
 
@@ -1155,7 +1154,7 @@ TEST_F(LayerTreeHostImplTest, ScrollWithUserUnscrollableLayers) {
 
   gfx::Size overflow_size(400, 400);
   ASSERT_EQ(1u, scroll_layer->children().size());
-  LayerImpl* overflow = scroll_layer->children()[0].get();
+  LayerImpl* overflow = scroll_layer->children()[0];
   overflow->SetBounds(overflow_size);
   overflow->SetScrollClipLayer(scroll_layer->parent()->parent()->id());
   overflow->layer_tree_impl()
@@ -1227,7 +1226,7 @@ TEST_F(LayerTreeHostImplTest, AnimationSchedulingPendingTree) {
   root->SetForceRenderSurface(true);
 
   root->AddChild(LayerImpl::Create(host_impl_->pending_tree(), 2));
-  LayerImpl* child = root->children()[0].get();
+  LayerImpl* child = root->children()[0];
   child->SetBounds(gfx::Size(10, 10));
   child->draw_properties().visible_layer_rect = gfx::Rect(10, 10);
   child->SetDrawsContent(true);
@@ -1277,7 +1276,7 @@ TEST_F(LayerTreeHostImplTest, AnimationSchedulingActiveTree) {
   root->SetForceRenderSurface(true);
 
   root->AddChild(LayerImpl::Create(host_impl_->active_tree(), 2));
-  LayerImpl* child = root->children()[0].get();
+  LayerImpl* child = root->children()[0];
   child->SetBounds(gfx::Size(10, 10));
   child->draw_properties().visible_layer_rect = gfx::Rect(10, 10);
   child->SetDrawsContent(true);
@@ -1341,7 +1340,7 @@ TEST_F(LayerTreeHostImplTest, AnimationSchedulingCommitToActiveTree) {
   root->SetHasRenderSurface(true);
 
   root->AddChild(LayerImpl::Create(host_impl_->active_tree(), 2));
-  LayerImpl* child = root->children()[0].get();
+  LayerImpl* child = root->children()[0];
   child->SetBounds(gfx::Size(10, 10));
   child->draw_properties().visible_layer_rect = gfx::Rect(10, 10);
   child->SetDrawsContent(true);
@@ -1400,7 +1399,7 @@ TEST_F(LayerTreeHostImplTest, AnimationMarksLayerNotReady) {
   root->AddChild(scoped_ptr<MissingTilesLayer>(
       new MissingTilesLayer(host_impl_->active_tree(), 2)));
   MissingTilesLayer* child =
-      static_cast<MissingTilesLayer*>(root->children()[0].get());
+      static_cast<MissingTilesLayer*>(root->children()[0]);
   child->SetBounds(gfx::Size(10, 10));
   child->draw_properties().visible_layer_rect = gfx::Rect(10, 10);
   child->SetDrawsContent(true);
@@ -3261,7 +3260,7 @@ TEST_F(LayerTreeHostImplTest, WillDrawReturningFalseDoesNotCall) {
   root->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
   root->SetForceRenderSurface(true);
   DidDrawCheckLayer* layer =
-      static_cast<DidDrawCheckLayer*>(root->children()[0].get());
+      static_cast<DidDrawCheckLayer*>(root->children()[0]);
 
   {
     LayerTreeHostImpl::FrameData frame;
@@ -3303,7 +3302,7 @@ TEST_F(LayerTreeHostImplTest, DidDrawNotCalledOnHiddenLayer) {
   root->SetForceRenderSurface(true);
   root->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
   DidDrawCheckLayer* layer =
-      static_cast<DidDrawCheckLayer*>(root->children()[0].get());
+      static_cast<DidDrawCheckLayer*>(root->children()[0]);
   // Ensure visible_layer_rect for layer is empty.
   layer->SetPosition(gfx::PointF(100.f, 100.f));
   layer->SetBounds(gfx::Size(10, 10));
@@ -3352,12 +3351,12 @@ TEST_F(LayerTreeHostImplTest, WillDrawNotCalledOnOccludedLayer) {
 
   root->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
   DidDrawCheckLayer* occluded_layer =
-      static_cast<DidDrawCheckLayer*>(root->children()[0].get());
+      static_cast<DidDrawCheckLayer*>(root->children()[0]);
 
   root->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 3));
   root->SetForceRenderSurface(true);
   DidDrawCheckLayer* top_layer =
-      static_cast<DidDrawCheckLayer*>(root->children()[1].get());
+      static_cast<DidDrawCheckLayer*>(root->children()[1]);
   // This layer covers the occluded_layer above. Make this layer large so it can
   // occlude.
   top_layer->SetBounds(big_size);
@@ -3389,11 +3388,11 @@ TEST_F(LayerTreeHostImplTest, DidDrawCalledOnAllLayers) {
   root->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
   root->SetForceRenderSurface(true);
   DidDrawCheckLayer* layer1 =
-      static_cast<DidDrawCheckLayer*>(root->children()[0].get());
+      static_cast<DidDrawCheckLayer*>(root->children()[0]);
 
   layer1->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 3));
   DidDrawCheckLayer* layer2 =
-      static_cast<DidDrawCheckLayer*>(layer1->children()[0].get());
+      static_cast<DidDrawCheckLayer*>(layer1->children()[0]);
 
   layer1->SetForceRenderSurface(true);
   layer1->SetShouldFlattenTransform(true);
@@ -3566,7 +3565,7 @@ TEST_F(LayerTreeHostImplTest, PrepareToDrawSucceedsAndFails) {
     const auto& testcase = cases[i];
     std::vector<LayerImpl*> to_remove;
     for (const auto& child : root->children())
-      to_remove.push_back(child.get());
+      to_remove.push_back(child);
     for (auto* child : to_remove)
       root->RemoveChild(child);
     timeline()->ClearPlayers();
@@ -3581,7 +3580,7 @@ TEST_F(LayerTreeHostImplTest, PrepareToDrawSucceedsAndFails) {
         testcase.layer_before.is_animating, host_impl_->resource_provider(),
         timeline()));
     DidDrawCheckLayer* before =
-        static_cast<DidDrawCheckLayer*>(root->children().back().get());
+        static_cast<DidDrawCheckLayer*>(root->children().back());
     if (testcase.layer_before.has_copy_request)
       before->AddCopyRequest();
 
@@ -3591,7 +3590,7 @@ TEST_F(LayerTreeHostImplTest, PrepareToDrawSucceedsAndFails) {
         testcase.layer_between.is_animating, host_impl_->resource_provider(),
         timeline()));
     DidDrawCheckLayer* between =
-        static_cast<DidDrawCheckLayer*>(root->children().back().get());
+        static_cast<DidDrawCheckLayer*>(root->children().back());
     if (testcase.layer_between.has_copy_request)
       between->AddCopyRequest();
 
@@ -3601,7 +3600,7 @@ TEST_F(LayerTreeHostImplTest, PrepareToDrawSucceedsAndFails) {
         testcase.layer_after.is_animating, host_impl_->resource_provider(),
         timeline()));
     DidDrawCheckLayer* after =
-        static_cast<DidDrawCheckLayer*>(root->children().back().get());
+        static_cast<DidDrawCheckLayer*>(root->children().back());
     if (testcase.layer_after.has_copy_request)
       after->AddCopyRequest();
 
@@ -3661,7 +3660,7 @@ TEST_F(LayerTreeHostImplTest,
     const auto& testcase = cases[i];
     std::vector<LayerImpl*> to_remove;
     for (const auto& child : root->children())
-      to_remove.push_back(child.get());
+      to_remove.push_back(child);
     for (auto* child : to_remove)
       root->RemoveChild(child);
 
@@ -3675,7 +3674,7 @@ TEST_F(LayerTreeHostImplTest,
         testcase.layer_before.is_animating, host_impl_->resource_provider(),
         timeline()));
     DidDrawCheckLayer* before =
-        static_cast<DidDrawCheckLayer*>(root->children().back().get());
+        static_cast<DidDrawCheckLayer*>(root->children().back());
     if (testcase.layer_before.has_copy_request)
       before->AddCopyRequest();
 
@@ -3685,7 +3684,7 @@ TEST_F(LayerTreeHostImplTest,
         testcase.layer_between.is_animating, host_impl_->resource_provider(),
         timeline()));
     DidDrawCheckLayer* between =
-        static_cast<DidDrawCheckLayer*>(root->children().back().get());
+        static_cast<DidDrawCheckLayer*>(root->children().back());
     if (testcase.layer_between.has_copy_request)
       between->AddCopyRequest();
 
@@ -3695,7 +3694,7 @@ TEST_F(LayerTreeHostImplTest,
         testcase.layer_after.is_animating, host_impl_->resource_provider(),
         timeline()));
     DidDrawCheckLayer* after =
-        static_cast<DidDrawCheckLayer*>(root->children().back().get());
+        static_cast<DidDrawCheckLayer*>(root->children().back());
     if (testcase.layer_after.has_copy_request)
       after->AddCopyRequest();
 
@@ -3855,8 +3854,7 @@ TEST_F(LayerTreeHostImplTopControlsTest,
   int id = host_impl_->OuterViewportScrollLayer()->id();
   host_impl_->OuterViewportScrollLayer()->AddChild(
       LayerImpl::Create(host_impl_->active_tree(), id + 2));
-  LayerImpl* content =
-      active_tree->OuterViewportScrollLayer()->children()[0].get();
+  LayerImpl* content = active_tree->OuterViewportScrollLayer()->children()[0];
   content->SetBounds(gfx::Size(50, 50));
 
   SetNeedsRebuildPropertyTrees();
@@ -4777,7 +4775,7 @@ TEST_F(LayerTreeHostImplTest, PageScaleDeltaAppliedToRootScrollLayerOnly) {
   LayerImpl* scroll = SetupScrollAndContentsLayers(surface_size);
   scroll->SetDrawsContent(true);
   LayerImpl* root = host_impl_->active_tree()->root_layer();
-  LayerImpl* child = scroll->children()[0].get();
+  LayerImpl* child = scroll->children()[0];
   child->SetDrawsContent(true);
 
   scoped_ptr<LayerImpl> scrollable_child_clip =
@@ -4786,7 +4784,7 @@ TEST_F(LayerTreeHostImplTest, PageScaleDeltaAppliedToRootScrollLayerOnly) {
       CreateScrollableLayer(7, surface_size, scrollable_child_clip.get());
   scrollable_child_clip->AddChild(std::move(scrollable_child));
   child->AddChild(std::move(scrollable_child_clip));
-  LayerImpl* grand_child = child->children()[0].get();
+  LayerImpl* grand_child = child->children()[0];
   grand_child->SetDrawsContent(true);
 
   // Set new page scale on impl thread by pinching.
@@ -4903,9 +4901,8 @@ TEST_F(LayerTreeHostImplTest, ScrollChildBeyondLimit) {
         host_impl_->ProcessScrollDeltas();
 
     // The grand child should have scrolled up to its limit.
-    LayerImpl* child =
-        host_impl_->active_tree()->root_layer()->children()[0].get();
-    LayerImpl* grand_child = child->children()[0].get();
+    LayerImpl* child = host_impl_->active_tree()->root_layer()->children()[0];
+    LayerImpl* grand_child = child->children()[0];
     EXPECT_TRUE(ScrollInfoContains(*scroll_info.get(), grand_child->id(),
                                    gfx::Vector2d(0, -5)));
 
@@ -4975,9 +4972,8 @@ TEST_F(LayerTreeHostImplTest, ScrollWithoutBubbling) {
                            ->root_layer()
                            ->children()[0]
                            ->children()[0]
-                           ->children()[0]
-                           .get();
-    LayerImpl* grand_child = child->children()[0].get();
+                           ->children()[0];
+    LayerImpl* grand_child = child->children()[0];
     EXPECT_TRUE(ScrollInfoContains(*scroll_info.get(), grand_child->id(),
                                    gfx::Vector2d(0, -2)));
 
@@ -5119,7 +5115,7 @@ TEST_F(LayerTreeHostImplTest, ScrollBeforeRedraw) {
   // synchronization.
   SetNeedsRebuildPropertyTrees();
   DrawFrame();
-  host_impl_->active_tree()->DetachLayerTree();
+  host_impl_->active_tree()->ClearLayers();
   scoped_ptr<LayerImpl> root_ptr2 =
       LayerImpl::Create(host_impl_->active_tree(), 4);
   scoped_ptr<LayerImpl> root_clip2 =
@@ -6051,7 +6047,7 @@ TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
                                    2,
                                    host_impl_->resource_provider()));
   BlendStateCheckLayer* layer1 =
-      static_cast<BlendStateCheckLayer*>(root->children()[0].get());
+      static_cast<BlendStateCheckLayer*>(root->children()[0]);
   layer1->SetPosition(gfx::PointF(2.f, 2.f));
 
   LayerTreeHostImpl::FrameData frame;
@@ -6105,7 +6101,7 @@ TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
                                    3,
                                    host_impl_->resource_provider()));
   BlendStateCheckLayer* layer2 =
-      static_cast<BlendStateCheckLayer*>(layer1->children()[0].get());
+      static_cast<BlendStateCheckLayer*>(layer1->children()[0]);
   layer2->SetPosition(gfx::PointF(4.f, 4.f));
 
   // 2 opaque layers, drawn without blending.
@@ -6313,7 +6309,7 @@ class LayerTreeHostImplViewportCoveredTest : public LayerTreeHostImplTest {
                                      2,
                                      host_impl_->resource_provider()));
     child_ = static_cast<BlendStateCheckLayer*>(
-        host_impl_->active_tree()->root_layer()->children()[0].get());
+        host_impl_->active_tree()->root_layer()->children()[0]);
     child_->SetExpectation(false, false);
     child_->SetContentsOpaque(true);
   }
@@ -7204,8 +7200,7 @@ class LayerTreeHostImplTestWithDelegatingRenderer
       // culled.
       ASSERT_EQ(2u, root_render_pass->quad_list.size());
 
-      LayerImpl* child =
-          host_impl_->active_tree()->root_layer()->children()[0].get();
+      LayerImpl* child = host_impl_->active_tree()->root_layer()->children()[0];
       gfx::Rect expected_child_visible_rect(child->bounds());
       EXPECT_EQ(expected_child_visible_rect,
                 root_render_pass->quad_list.front()->visible_rect);
@@ -7738,9 +7733,8 @@ TEST_F(LayerTreeHostImplTest, TouchFlingShouldContinueScrollingCurrentLayer) {
   {
     scoped_ptr<ScrollAndScaleSet> scroll_info;
     LayerImpl* child =
-        host_impl_->active_tree()->root_layer()->children()[0]->children()
-            [0].get();
-    LayerImpl* grand_child = child->children()[0].get();
+        host_impl_->active_tree()->root_layer()->children()[0]->children()[0];
+    LayerImpl* grand_child = child->children()[0];
 
     gfx::Vector2d scroll_delta(0, -2);
     EXPECT_EQ(InputHandler::SCROLL_ON_IMPL_THREAD,
@@ -9324,10 +9318,8 @@ TEST_F(LayerTreeHostImplTest, ExternalTileConstraintReflectedInPendingTree) {
 TEST_F(LayerTreeHostImplTest, ExternalViewportAffectsVisibleRects) {
   const gfx::Size layer_size(100, 100);
   SetupScrollAndContentsLayers(layer_size);
-  LayerImpl* content_layer = host_impl_->active_tree()
-                                 ->OuterViewportScrollLayer()
-                                 ->children()[0]
-                                 .get();
+  LayerImpl* content_layer =
+      host_impl_->active_tree()->OuterViewportScrollLayer()->children()[0];
   SetNeedsRebuildPropertyTrees();
   RebuildPropertyTrees();
 
@@ -9360,10 +9352,8 @@ TEST_F(LayerTreeHostImplTest, ExternalViewportAffectsVisibleRects) {
 TEST_F(LayerTreeHostImplTest, ExternalTransformAffectsVisibleRects) {
   const gfx::Size layer_size(100, 100);
   SetupScrollAndContentsLayers(layer_size);
-  LayerImpl* content_layer = host_impl_->active_tree()
-                                 ->OuterViewportScrollLayer()
-                                 ->children()[0]
-                                 .get();
+  LayerImpl* content_layer =
+      host_impl_->active_tree()->OuterViewportScrollLayer()->children()[0];
   SetNeedsRebuildPropertyTrees();
   RebuildPropertyTrees();
 
@@ -9401,10 +9391,8 @@ TEST_F(LayerTreeHostImplTest, ExternalTransformAffectsVisibleRects) {
 TEST_F(LayerTreeHostImplTest, ExternalTransformAffectsSublayerScaleFactor) {
   const gfx::Size layer_size(100, 100);
   SetupScrollAndContentsLayers(layer_size);
-  LayerImpl* content_layer = host_impl_->active_tree()
-                                 ->OuterViewportScrollLayer()
-                                 ->children()[0]
-                                 .get();
+  LayerImpl* content_layer =
+      host_impl_->active_tree()->OuterViewportScrollLayer()->children()[0];
   content_layer->AddChild(LayerImpl::Create(host_impl_->active_tree(), 100));
   LayerImpl* test_layer = host_impl_->active_tree()->LayerById(100);
   test_layer->SetForceRenderSurface(true);
@@ -10353,10 +10341,8 @@ TEST_F(LayerTreeHostImplTest, JitterTest) {
 
     host_impl_->CreatePendingTree();
     host_impl_->pending_tree()->set_source_frame_number(i + 1);
-    LayerImpl* content_layer = host_impl_->pending_tree()
-                                   ->OuterViewportScrollLayer()
-                                   ->children()[0]
-                                   .get();
+    LayerImpl* content_layer =
+        host_impl_->pending_tree()->OuterViewportScrollLayer()->children()[0];
     // The scroll done on the active tree is undone on the pending tree.
     gfx::Transform translate;
     translate.Translate(0, accumulated_scroll);
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index 673d586..a923346 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -1740,7 +1740,7 @@ class LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers
     FakePictureLayerImpl* root =
         static_cast<FakePictureLayerImpl*>(impl->active_tree()->root_layer());
     FakePictureLayerImpl* child = static_cast<FakePictureLayerImpl*>(
-        impl->active_tree()->root_layer()->children()[0].get());
+        impl->active_tree()->root_layer()->children()[0]);
 
     // Positions remain in layout pixels.
     EXPECT_EQ(gfx::PointF(), root->position());
@@ -3130,21 +3130,21 @@ class LayerTreeHostTestImplLayersPushProperties
 
     if (root_impl_ && root_impl_->children().size() > 0) {
       child_impl_ = static_cast<PushPropertiesCountingLayerImpl*>(
-          root_impl_->children()[0].get());
+          root_impl_->children()[0]);
 
       if (child_impl_ && child_impl_->children().size() > 0)
         grandchild_impl_ = static_cast<PushPropertiesCountingLayerImpl*>(
-            child_impl_->children()[0].get());
+            child_impl_->children()[0]);
     }
 
     if (root_impl_ && root_impl_->children().size() > 1) {
       child2_impl_ = static_cast<PushPropertiesCountingLayerImpl*>(
-          root_impl_->children()[1].get());
+          root_impl_->children()[1]);
 
       if (child2_impl_ && child2_impl_->children().size() > 0)
         leaf_always_pushing_layer_impl_ =
             static_cast<PushPropertiesCountingLayerImpl*>(
-                child2_impl_->children()[0].get());
+                child2_impl_->children()[0]);
     }
 
     if (root_impl_)
@@ -3883,8 +3883,8 @@ class LayerTreeHostTestPushHiddenLayer : public LayerTreeHostTest {
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->active_tree()->root_layer();
-    LayerImpl* parent = root->children()[0].get();
-    LayerImpl* child = parent->children()[0].get();
+    LayerImpl* parent = root->children()[0];
+    LayerImpl* child = parent->children()[0];
 
     switch (impl->active_tree()->source_frame_number()) {
       case 1:
@@ -3984,10 +3984,8 @@ class LayerTreeHostTestElasticOverscroll : public LayerTreeHostTest {
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     num_draws_++;
-    LayerImpl* content_layer_impl = host_impl->active_tree()
-                                        ->InnerViewportScrollLayer()
-                                        ->children()[0]
-                                        .get();
+    LayerImpl* content_layer_impl =
+        host_impl->active_tree()->InnerViewportScrollLayer()->children()[0];
     gfx::Transform expected_draw_transform;
     switch (num_draws_) {
       case 1:
diff --git a/cc/trees/layer_tree_host_unittest_animation.cc b/cc/trees/layer_tree_host_unittest_animation.cc
index 8195714..b8a63e3 100644
--- a/cc/trees/layer_tree_host_unittest_animation.cc
+++ b/cc/trees/layer_tree_host_unittest_animation.cc
@@ -834,7 +834,7 @@ class LayerTreeHostAnimationTestScrollOffsetAnimationRemoval
         timeline_impl->GetPlayerById(player_child_id_);
 
     LayerImpl* scroll_layer_impl =
-        host_impl->active_tree()->root_layer()->children()[0].get();
+        host_impl->active_tree()->root_layer()->children()[0];
     Animation* animation = player_impl->element_animations()
                                ->layer_animation_controller()
                                ->GetAnimation(TargetProperty::SCROLL_OFFSET);
@@ -857,7 +857,7 @@ class LayerTreeHostAnimationTestScrollOffsetAnimationRemoval
     if (host_impl->pending_tree()->source_frame_number() != 1)
       return;
     LayerImpl* scroll_layer_impl =
-        host_impl->pending_tree()->root_layer()->children()[0].get();
+        host_impl->pending_tree()->root_layer()->children()[0];
     EXPECT_EQ(final_postion_, scroll_layer_impl->CurrentScrollOffset());
   }
 
@@ -865,7 +865,7 @@ class LayerTreeHostAnimationTestScrollOffsetAnimationRemoval
     if (host_impl->active_tree()->source_frame_number() != 1)
       return;
     LayerImpl* scroll_layer_impl =
-        host_impl->active_tree()->root_layer()->children()[0].get();
+        host_impl->active_tree()->root_layer()->children()[0];
     EXPECT_EQ(final_postion_, scroll_layer_impl->CurrentScrollOffset());
     EndTest();
   }
@@ -1030,7 +1030,7 @@ class LayerTreeHostAnimationTestPendingTreeAnimatesFirstCommit
         player_impl->element_animations()->layer_animation_controller();
 
     LayerImpl* root = host_impl->sync_tree()->root_layer();
-    LayerImpl* child = root->children()[0].get();
+    LayerImpl* child = root->children()[0];
     Animation* animation =
         controller_impl->GetAnimation(TargetProperty::TRANSFORM);
 
@@ -1269,7 +1269,7 @@ class LayerTreeHostAnimationTestRemoveAnimation
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     LayerImpl* root = host_impl->active_tree()->root_layer();
-    LayerImpl* child = root->children()[0].get();
+    LayerImpl* child = root->children()[0];
     switch (host_impl->active_tree()->source_frame_number()) {
       case 0:
         // No animation yet.
@@ -1335,7 +1335,7 @@ class LayerTreeHostAnimationTestIsAnimating
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     LayerImpl* root = host_impl->sync_tree()->root_layer();
-    LayerImpl* child = root->children()[0].get();
+    LayerImpl* child = root->children()[0];
     switch (host_impl->sync_tree()->source_frame_number()) {
       case 0:
         // No animation yet.
@@ -1356,7 +1356,7 @@ class LayerTreeHostAnimationTestIsAnimating
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     LayerImpl* root = host_impl->active_tree()->root_layer();
-    LayerImpl* child = root->children()[0].get();
+    LayerImpl* child = root->children()[0];
     switch (host_impl->active_tree()->source_frame_number()) {
       case 0:
         // No animation yet.
@@ -1430,7 +1430,7 @@ class LayerTreeHostAnimationTestAnimationFinishesDuringCommit
         gfx::Transform expected_transform;
         expected_transform.Translate(5.f, 5.f);
         LayerImpl* layer_impl =
-            host_impl->sync_tree()->root_layer()->children()[0].get();
+            host_impl->sync_tree()->root_layer()->children()[0];
         EXPECT_EQ(expected_transform, layer_impl->DrawTransform());
         EndTest();
         break;
diff --git a/cc/trees/layer_tree_host_unittest_context.cc b/cc/trees/layer_tree_host_unittest_context.cc
index 34fc313..7f17e0f 100644
--- a/cc/trees/layer_tree_host_unittest_context.cc
+++ b/cc/trees/layer_tree_host_unittest_context.cc
@@ -647,7 +647,7 @@ class LayerTreeHostContextTestLostContextSucceedsWithContent
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     FakePictureLayerImpl* picture_impl = static_cast<FakePictureLayerImpl*>(
-        host_impl->active_tree()->root_layer()->children()[0].get());
+        host_impl->active_tree()->root_layer()->children()[0]);
     EXPECT_TRUE(picture_impl->HighResTiling()
                     ->TileAt(0, 0)
                     ->draw_info()
@@ -858,9 +858,9 @@ class LayerTreeHostContextTestLayersNotified : public LayerTreeHostContextTest {
     root_picture = static_cast<FakePictureLayerImpl*>(
         host_impl->active_tree()->root_layer());
     child_picture =
-        static_cast<FakePictureLayerImpl*>(root_picture->children()[0].get());
+        static_cast<FakePictureLayerImpl*>(root_picture->children()[0]);
     grandchild_picture =
-        static_cast<FakePictureLayerImpl*>(child_picture->children()[0].get());
+        static_cast<FakePictureLayerImpl*>(child_picture->children()[0]);
 
     ++num_commits_;
     switch (num_commits_) {
diff --git a/cc/trees/layer_tree_host_unittest_copyrequest.cc b/cc/trees/layer_tree_host_unittest_copyrequest.cc
index 186350e..ab4a456 100644
--- a/cc/trees/layer_tree_host_unittest_copyrequest.cc
+++ b/cc/trees/layer_tree_host_unittest_copyrequest.cc
@@ -478,9 +478,9 @@ class LayerTreeHostTestHiddenSurfaceNotAllocatedForSubtreeCopyRequest
     Renderer* renderer = host_impl->renderer();
 
     LayerImpl* root = host_impl->active_tree()->root_layer();
-    LayerImpl* grand_parent = root->children()[0].get();
-    LayerImpl* parent = grand_parent->children()[0].get();
-    LayerImpl* copy_layer = parent->children()[0].get();
+    LayerImpl* grand_parent = root->children()[0];
+    LayerImpl* parent = grand_parent->children()[0];
+    LayerImpl* copy_layer = parent->children()[0];
 
     // |parent| owns a surface, but it was hidden and not part of the copy
     // request so it should not allocate any resource.
@@ -1191,7 +1191,7 @@ class LayerTreeHostCopyRequestTestMultipleDrawsHiddenCopyRequest
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     LayerImpl* root = host_impl->active_tree()->root_layer();
-    LayerImpl* child = root->children()[0].get();
+    LayerImpl* child = root->children()[0];
 
     bool saw_root = false;
     bool saw_child = false;
diff --git a/cc/trees/layer_tree_host_unittest_damage.cc b/cc/trees/layer_tree_host_unittest_damage.cc
index fdb3e17..76c26f6 100644
--- a/cc/trees/layer_tree_host_unittest_damage.cc
+++ b/cc/trees/layer_tree_host_unittest_damage.cc
@@ -411,8 +411,8 @@ class LayerTreeHostDamageTestScrollbarDoesDamage
     ++did_swaps_;
     EXPECT_TRUE(result);
     LayerImpl* root = host_impl->active_tree()->root_layer();
-    LayerImpl* scroll_clip_layer = root->children()[0].get();
-    LayerImpl* scroll_layer = scroll_clip_layer->children()[0].get();
+    LayerImpl* scroll_clip_layer = root->children()[0];
+    LayerImpl* scroll_layer = scroll_clip_layer->children()[0];
     switch (did_swaps_) {
       case 1:
         // Test that modifying the position of the content layer (not
@@ -504,8 +504,8 @@ class LayerTreeHostDamageTestScrollbarCommitDoesNoDamage
     ++did_swaps_;
     EXPECT_TRUE(result);
     LayerImpl* root = host_impl->active_tree()->root_layer();
-    LayerImpl* scroll_clip_layer = root->children()[0].get();
-    LayerImpl* scroll_layer = scroll_clip_layer->children()[0].get();
+    LayerImpl* scroll_clip_layer = root->children()[0];
+    LayerImpl* scroll_layer = scroll_clip_layer->children()[0];
     switch (did_swaps_) {
       case 1:
         // Scroll on the thread.  This should damage the scrollbar for the
diff --git a/cc/trees/layer_tree_host_unittest_occlusion.cc b/cc/trees/layer_tree_host_unittest_occlusion.cc
index 679128a..9f35bd9 100644
--- a/cc/trees/layer_tree_host_unittest_occlusion.cc
+++ b/cc/trees/layer_tree_host_unittest_occlusion.cc
@@ -49,7 +49,7 @@ class LayerTreeHostOcclusionTestDrawPropertiesOnLayer
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->active_tree()->root_layer();
-    LayerImpl* child = root->children()[0].get();
+    LayerImpl* child = root->children()[0];
 
     // Verify the draw properties are valid.
     EXPECT_TRUE(root->IsDrawnRenderSurfaceLayerListMember());
@@ -102,7 +102,7 @@ class LayerTreeHostOcclusionTestDrawPropertiesOnSurface
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->active_tree()->root_layer();
-    LayerImpl* child = root->children()[0].get();
+    LayerImpl* child = root->children()[0];
     RenderSurfaceImpl* surface = child->render_surface();
 
     // Verify the draw properties are valid.
@@ -165,7 +165,7 @@ class LayerTreeHostOcclusionTestDrawPropertiesOnMask
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->active_tree()->root_layer();
-    LayerImpl* child = root->children()[0].get();
+    LayerImpl* child = root->children()[0];
     RenderSurfaceImpl* surface = child->render_surface();
     LayerImpl* mask = child->mask_layer();
 
@@ -235,7 +235,7 @@ class LayerTreeHostOcclusionTestDrawPropertiesOnScaledMask
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->active_tree()->root_layer();
-    LayerImpl* child = root->children()[0].get();
+    LayerImpl* child = root->children()[0];
     LayerImpl* mask = child->mask_layer();
 
     gfx::Transform scale;
@@ -302,7 +302,7 @@ class LayerTreeHostOcclusionTestDrawPropertiesInsideReplica
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->active_tree()->root_layer();
-    LayerImpl* child = root->children()[0].get();
+    LayerImpl* child = root->children()[0];
     RenderSurfaceImpl* surface = child->render_surface();
     LayerImpl* mask = child->mask_layer();
 
diff --git a/cc/trees/layer_tree_host_unittest_picture.cc b/cc/trees/layer_tree_host_unittest_picture.cc
index df4a3c9..c41a252 100644
--- a/cc/trees/layer_tree_host_unittest_picture.cc
+++ b/cc/trees/layer_tree_host_unittest_picture.cc
@@ -82,8 +82,7 @@ class LayerTreeHostPictureTestTwinLayer
     }
 
     FakePictureLayerImpl* pending_picture_impl =
-        static_cast<FakePictureLayerImpl*>(
-            pending_root_impl->children()[0].get());
+        static_cast<FakePictureLayerImpl*>(pending_root_impl->children()[0]);
 
     if (!active_root_impl) {
       EXPECT_EQ(0, activates_);
@@ -98,8 +97,7 @@ class LayerTreeHostPictureTestTwinLayer
     }
 
     FakePictureLayerImpl* active_picture_impl =
-        static_cast<FakePictureLayerImpl*>(
-            active_root_impl->children()[0].get());
+        static_cast<FakePictureLayerImpl*>(active_root_impl->children()[0]);
 
     // After the first activation, when we commit again, we'll have a pending
     // and active layer. Then we recreate a picture layer in the 4th activate
@@ -118,8 +116,7 @@ class LayerTreeHostPictureTestTwinLayer
       EXPECT_EQ(2, activates_);
     } else {
       FakePictureLayerImpl* active_picture_impl =
-          static_cast<FakePictureLayerImpl*>(
-              active_root_impl->children()[0].get());
+          static_cast<FakePictureLayerImpl*>(active_root_impl->children()[0]);
       EXPECT_EQ(nullptr, active_picture_impl->GetPendingOrActiveTwinLayer());
     }
 
@@ -156,7 +153,7 @@ class LayerTreeHostPictureTestResizeViewportWithGpuRaster
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
-    LayerImpl* child = impl->sync_tree()->root_layer()->children()[0].get();
+    LayerImpl* child = impl->sync_tree()->root_layer()->children()[0];
     FakePictureLayerImpl* picture_impl =
         static_cast<FakePictureLayerImpl*>(child);
     gfx::Size tile_size =
@@ -225,7 +222,7 @@ class LayerTreeHostPictureTestChangeLiveTilesRectWithRecycleTree
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
-    LayerImpl* child = impl->active_tree()->root_layer()->children()[0].get();
+    LayerImpl* child = impl->active_tree()->root_layer()->children()[0];
     FakePictureLayerImpl* picture_impl =
         static_cast<FakePictureLayerImpl*>(child);
     switch (++frame_) {
@@ -274,7 +271,7 @@ class LayerTreeHostPictureTestChangeLiveTilesRectWithRecycleTree
   }
 
   void WillActivateTreeOnThread(LayerTreeHostImpl* impl) override {
-    LayerImpl* child = impl->sync_tree()->root_layer()->children()[0].get();
+    LayerImpl* child = impl->sync_tree()->root_layer()->children()[0];
     FakePictureLayerImpl* picture_impl =
         static_cast<FakePictureLayerImpl*>(child);
     PictureLayerTiling* tiling = picture_impl->HighResTiling();
@@ -329,8 +326,8 @@ class LayerTreeHostPictureTestRSLLMembership : public LayerTreeHostPictureTest {
 
   void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->sync_tree()->root_layer();
-    LayerImpl* child = root->children()[0].get();
-    LayerImpl* gchild = child->children()[0].get();
+    LayerImpl* child = root->children()[0];
+    LayerImpl* gchild = child->children()[0];
     FakePictureLayerImpl* picture = static_cast<FakePictureLayerImpl*>(gchild);
 
     switch (impl->sync_tree()->source_frame_number()) {
@@ -351,8 +348,8 @@ class LayerTreeHostPictureTestRSLLMembership : public LayerTreeHostPictureTest {
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->active_tree()->root_layer();
-    LayerImpl* child = root->children()[0].get();
-    LayerImpl* gchild = child->children()[0].get();
+    LayerImpl* child = root->children()[0];
+    LayerImpl* gchild = child->children()[0];
     FakePictureLayerImpl* picture = static_cast<FakePictureLayerImpl*>(gchild);
 
     switch (impl->active_tree()->source_frame_number()) {
@@ -438,8 +435,8 @@ class LayerTreeHostPictureTestRSLLMembershipWithScale
 
   void WillActivateTreeOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->sync_tree()->root_layer();
-    LayerImpl* pinch = root->children()[0]->children()[0].get();
-    LayerImpl* gchild = pinch->children()[0].get();
+    LayerImpl* pinch = root->children()[0]->children()[0];
+    LayerImpl* gchild = pinch->children()[0];
     FakePictureLayerImpl* picture = static_cast<FakePictureLayerImpl*>(gchild);
     ready_to_draw_ = false;
 
@@ -465,8 +462,8 @@ class LayerTreeHostPictureTestRSLLMembershipWithScale
 
   void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
     LayerImpl* root = impl->active_tree()->root_layer();
-    LayerImpl* pinch = root->children()[0]->children()[0].get();
-    LayerImpl* gchild = pinch->children()[0].get();
+    LayerImpl* pinch = root->children()[0]->children()[0];
+    LayerImpl* gchild = pinch->children()[0];
     FakePictureLayerImpl* picture = static_cast<FakePictureLayerImpl*>(gchild);
 
     if (frame_ != last_frame_drawn_)
diff --git a/cc/trees/layer_tree_host_unittest_scroll.cc b/cc/trees/layer_tree_host_unittest_scroll.cc
index b056a76..b5fce20 100644
--- a/cc/trees/layer_tree_host_unittest_scroll.cc
+++ b/cc/trees/layer_tree_host_unittest_scroll.cc
@@ -606,7 +606,7 @@ class LayerTreeHostScrollTestCaseWithChild : public LayerTreeHostScrollTest {
     FakePictureLayerImpl* root_scroll_layer_impl =
         static_cast<FakePictureLayerImpl*>(impl->OuterViewportScrollLayer());
     FakePictureLayerImpl* child_layer_impl = static_cast<FakePictureLayerImpl*>(
-        root_scroll_layer_impl->children()[0].get());
+        root_scroll_layer_impl->children()[0]);
 
     LayerImpl* expected_scroll_layer_impl = NULL;
     LayerImpl* expected_no_scroll_layer_impl = NULL;
diff --git a/cc/trees/layer_tree_host_unittest_video.cc b/cc/trees/layer_tree_host_unittest_video.cc
index 46b8757..269ee8f 100644
--- a/cc/trees/layer_tree_host_unittest_video.cc
+++ b/cc/trees/layer_tree_host_unittest_video.cc
@@ -69,7 +69,7 @@ class LayerTreeHostVideoTestSetNeedsDisplay
 
   void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
     VideoLayerImpl* video = static_cast<VideoLayerImpl*>(
-        host_impl->active_tree()->root_layer()->children()[0].get());
+        host_impl->active_tree()->root_layer()->children()[0]);
 
     EXPECT_EQ(media::VIDEO_ROTATION_90, video->video_rotation());
 
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 074ab1d..35406d4 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -57,7 +57,8 @@ LayerTreeImpl::LayerTreeImpl(
     : 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),
@@ -71,6 +72,7 @@ LayerTreeImpl::LayerTreeImpl(
       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),
@@ -96,21 +98,22 @@ LayerTreeImpl::~LayerTreeImpl() {
 }
 
 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(); });
   }
 }
 
@@ -123,7 +126,7 @@ void LayerTreeImpl::GatherFrameTimingRequestIds(
   // 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);
       });
 }
@@ -269,8 +272,11 @@ void LayerTreeImpl::UpdateScrollbars(int scroll_layer_id, int clip_layer_id) {
 }
 
 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();
 }
 
@@ -306,10 +312,18 @@ gfx::ScrollOffset LayerTreeImpl::TotalMaxScrollOffset() const {
   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,
@@ -418,7 +432,7 @@ void LayerTreeImpl::PushPropertiesTo(LayerTreeImpl* target_tree) {
 }
 
 LayerListIterator LayerTreeImpl::begin() {
-  return LayerListIterator(root_layer_.get());
+  return LayerListIterator(root_layer_);
 }
 
 LayerListIterator LayerTreeImpl::end() {
@@ -426,7 +440,7 @@ LayerListIterator LayerTreeImpl::end() {
 }
 
 LayerListReverseIterator LayerTreeImpl::rbegin() {
-  return LayerListReverseIterator(root_layer_.get());
+  return LayerListReverseIterator(root_layer_);
 }
 
 LayerListReverseIterator LayerTreeImpl::rend() {
@@ -711,7 +725,7 @@ gfx::Rect LayerTreeImpl::RootScrollLayerDeviceViewportBounds() const {
                                      : 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()));
 }
@@ -946,10 +960,10 @@ bool LayerTreeImpl::UpdateDrawProperties(bool update_lcd_text) {
 }
 
 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(),
@@ -992,7 +1006,7 @@ gfx::SizeF LayerTreeImpl::ScrollableSize() const {
 }
 
 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;
 }
 
@@ -1028,6 +1042,28 @@ void LayerTreeImpl::UnregisterLayer(LayerImpl* layer) {
       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() {
diff --git a/cc/trees/layer_tree_impl.h b/cc/trees/layer_tree_impl.h
index b6776ce..ce68146 100644
--- a/cc/trees/layer_tree_impl.h
+++ b/cc/trees/layer_tree_impl.h
@@ -130,9 +130,10 @@ class CC_EXPORT LayerTreeImpl {
 
   // Other public methods
   // ---------------------------------------------------------------------------
-  LayerImpl* root_layer() const { return root_layer_.get(); }
+  LayerImpl* root_layer() const { return root_layer_; }
   void SetRootLayer(scoped_ptr<LayerImpl>);
-  scoped_ptr<LayerImpl> DetachLayerTree();
+  scoped_ptr<OwnedLayerImplList> DetachLayers();
+  void ClearLayers();
 
   void SetPropertyTrees(const PropertyTrees property_trees) {
     property_trees_ = property_trees;
@@ -307,6 +308,10 @@ class CC_EXPORT LayerTreeImpl {
   void RegisterLayer(LayerImpl* layer);
   void UnregisterLayer(LayerImpl* layer);
 
+  // These manage ownership of the LayerImpl.
+  void AddLayer(scoped_ptr<LayerImpl> layer);
+  scoped_ptr<LayerImpl> RemoveLayer(int id);
+
   size_t NumLayers();
 
   void DidBecomeActive();
@@ -496,7 +501,7 @@ class CC_EXPORT LayerTreeImpl {
   LayerTreeHostImpl* layer_tree_host_impl_;
   int source_frame_number_;
   int is_first_frame_after_commit_tracker_;
-  scoped_ptr<LayerImpl> root_layer_;
+  LayerImpl* root_layer_;
   HeadsUpDisplayLayerImpl* hud_layer_;
   PropertyTrees property_trees_;
   SkColor background_color_;
@@ -519,8 +524,8 @@ class CC_EXPORT LayerTreeImpl {
 
   scoped_refptr<SyncedElasticOverscroll> elastic_overscroll_;
 
-  using LayerIdMap = std::unordered_map<int, LayerImpl*>;
-  LayerIdMap layer_id_map_;
+  scoped_ptr<OwnedLayerImplList> layers_;
+  LayerImplMap layer_id_map_;
   // Set of layers that need to push properties.
   std::unordered_set<LayerImpl*> layers_that_should_push_properties_;
 
diff --git a/cc/trees/layer_tree_impl_unittest.cc b/cc/trees/layer_tree_impl_unittest.cc
index 195c44b..4a5f480 100644
--- a/cc/trees/layer_tree_impl_unittest.cc
+++ b/cc/trees/layer_tree_impl_unittest.cc
@@ -883,9 +883,9 @@ TEST_F(LayerTreeImplTest, HitTestingForMultipleLayers) {
     ExecuteCalculateDrawProperties(root.get());
   }
 
-  LayerImpl* child1 = root->children()[0].get();
-  LayerImpl* child2 = root->children()[1].get();
-  LayerImpl* grand_child1 = child1->children()[0].get();
+  LayerImpl* child1 = root->children()[0];
+  LayerImpl* child2 = root->children()[1];
+  LayerImpl* grand_child1 = child1->children()[0];
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(std::move(root));
@@ -1111,9 +1111,9 @@ TEST_F(LayerTreeImplTest, HitTestingForMultipleLayersAtVaryingDepths) {
     root->AddChild(std::move(child2));
   }
 
-  LayerImpl* child1 = root->children()[0].get();
-  LayerImpl* child2 = root->children()[1].get();
-  LayerImpl* grand_child1 = child1->children()[0].get();
+  LayerImpl* child1 = root->children()[0];
+  LayerImpl* child2 = root->children()[1];
+  LayerImpl* grand_child1 = child1->children()[0];
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(std::move(root));
@@ -1348,9 +1348,9 @@ TEST_F(LayerTreeImplTest, HitTestingForMultipleLayerLists) {
     ExecuteCalculateDrawProperties(root.get());
   }
 
-  LayerImpl* child1 = root->children()[0].get();
-  LayerImpl* child2 = root->children()[1].get();
-  LayerImpl* grand_child1 = child1->children()[0].get();
+  LayerImpl* child1 = root->children()[0];
+  LayerImpl* child2 = root->children()[1];
+  LayerImpl* grand_child1 = child1->children()[0];
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(std::move(root));
@@ -1692,7 +1692,7 @@ TEST_F(LayerTreeImplTest,
   // The visible content rect for test_layer is actually 100x100, even though
   // its layout size is 50x50, positioned at 25x25.
   LayerImpl* test_layer =
-      host_impl().active_tree()->root_layer()->children()[0].get();
+      host_impl().active_tree()->root_layer()->children()[0];
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 
@@ -1984,7 +1984,7 @@ TEST_F(LayerTreeImplTest, HitTestingTouchHandlerRegionsForLayerThatIsNotDrawn) {
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   LayerImpl* test_layer =
-      host_impl().active_tree()->root_layer()->children()[0].get();
+      host_impl().active_tree()->root_layer()->children()[0];
   // As test_layer doesn't draw content, the layer list of root's render surface
   // should contain only the root layer.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
@@ -2015,7 +2015,7 @@ TEST_F(LayerTreeImplTest, HitTestingTouchHandlerRegionsForLayerThatIsNotDrawn) {
 
   // We change the position of the test layer such that the test point is now
   // inside the test_layer.
-  test_layer = host_impl().active_tree()->root_layer()->children()[0].get();
+  test_layer = host_impl().active_tree()->root_layer()->children()[0];
   test_layer->SetPosition(gfx::PointF(10.f, 10.f));
   test_layer->NoteLayerPropertyChanged();
   expected_screen_space_transform.MakeIdentity();
diff --git a/cc/trees/tree_synchronizer.cc b/cc/trees/tree_synchronizer.cc
index a134bb4..d50a57d 100644
--- a/cc/trees/tree_synchronizer.cc
+++ b/cc/trees/tree_synchronizer.cc
@@ -7,128 +7,121 @@
 #include <stddef.h>
 
 #include <set>
-#include <unordered_map>
 
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/layers/layer.h"
+#include "cc/layers/layer_collections.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 
 namespace cc {
 
-using ScopedPtrLayerImplMap = std::unordered_map<int, scoped_ptr<LayerImpl>>;
-using RawPtrLayerImplMap = std::unordered_map<int, LayerImpl*>;
-
-void CollectExistingLayerImplRecursive(ScopedPtrLayerImplMap* old_layers,
-                                       scoped_ptr<LayerImpl> layer_impl) {
-  if (!layer_impl)
-    return;
-
-  OwnedLayerImplList& children = layer_impl->children();
-  for (auto& child : children)
-    CollectExistingLayerImplRecursive(old_layers, std::move(child));
-
-  CollectExistingLayerImplRecursive(old_layers, layer_impl->TakeMaskLayer());
-  CollectExistingLayerImplRecursive(old_layers, layer_impl->TakeReplicaLayer());
-
-  int id = layer_impl->id();
-  (*old_layers)[id] = std::move(layer_impl);
-}
-
 template <typename LayerType>
-scoped_ptr<LayerImpl> SynchronizeTreesInternal(
-    LayerType* layer_root,
-    scoped_ptr<LayerImpl> old_layer_impl_root,
-    LayerTreeImpl* tree_impl) {
+void SynchronizeTreesInternal(LayerType* layer_root, LayerTreeImpl* tree_impl) {
   DCHECK(tree_impl);
 
   TRACE_EVENT0("cc", "TreeSynchronizer::SynchronizeTrees");
-  ScopedPtrLayerImplMap old_layers;
-  RawPtrLayerImplMap new_layers;
+  scoped_ptr<OwnedLayerImplList> old_layers(tree_impl->DetachLayers());
 
-  CollectExistingLayerImplRecursive(&old_layers,
-                                    std::move(old_layer_impl_root));
+  OwnedLayerImplMap old_layer_map;
+  for (auto& it : *old_layers)
+    old_layer_map[it->id()] = std::move(it);
 
-  scoped_ptr<LayerImpl> new_tree = SynchronizeTreesRecursive(
-      &new_layers, &old_layers, layer_root, tree_impl);
+  SynchronizeTreesRecursive(&old_layer_map, layer_root, tree_impl);
 
-  return new_tree;
+  for (auto& it : old_layer_map) {
+    if (it.second) {
+      // Need to ensure that layer destruction doesn't tear down child
+      // LayerImpl that have been used in the new tree.
+      it.second->children().clear();
+    }
+  }
 }
 
-scoped_ptr<LayerImpl> TreeSynchronizer::SynchronizeTrees(
-    Layer* layer_root,
-    scoped_ptr<LayerImpl> old_layer_impl_root,
-    LayerTreeImpl* tree_impl) {
-  return SynchronizeTreesInternal(layer_root, std::move(old_layer_impl_root),
-                                  tree_impl);
+void TreeSynchronizer::SynchronizeTrees(Layer* layer_root,
+                                        LayerTreeImpl* tree_impl) {
+  if (!layer_root)
+    tree_impl->ClearLayers();
+  else
+    SynchronizeTreesInternal(layer_root, tree_impl);
 }
 
-scoped_ptr<LayerImpl> TreeSynchronizer::SynchronizeTrees(
-    LayerImpl* layer_root,
-    scoped_ptr<LayerImpl> old_layer_impl_root,
-    LayerTreeImpl* tree_impl) {
-  return SynchronizeTreesInternal(layer_root, std::move(old_layer_impl_root),
-                                  tree_impl);
+void TreeSynchronizer::SynchronizeTrees(LayerImpl* layer_root,
+                                        LayerTreeImpl* tree_impl) {
+  if (!layer_root)
+    tree_impl->ClearLayers();
+  else
+    SynchronizeTreesInternal(layer_root, tree_impl);
 }
 
 template <typename LayerType>
-scoped_ptr<LayerImpl> ReuseOrCreateLayerImpl(RawPtrLayerImplMap* new_layers,
-                                             ScopedPtrLayerImplMap* old_layers,
+scoped_ptr<LayerImpl> ReuseOrCreateLayerImpl(OwnedLayerImplMap* old_layers,
                                              LayerType* layer,
                                              LayerTreeImpl* tree_impl) {
+  if (!layer)
+    return nullptr;
   scoped_ptr<LayerImpl> layer_impl = std::move((*old_layers)[layer->id()]);
-
   if (!layer_impl)
     layer_impl = layer->CreateLayerImpl(tree_impl);
-
-  (*new_layers)[layer->id()] = layer_impl.get();
   return layer_impl;
 }
 
 template <typename LayerType>
 scoped_ptr<LayerImpl> SynchronizeTreesRecursiveInternal(
-    RawPtrLayerImplMap* new_layers,
-    ScopedPtrLayerImplMap* old_layers,
+    OwnedLayerImplMap* old_layers,
     LayerType* layer,
     LayerTreeImpl* tree_impl) {
   if (!layer)
     return nullptr;
 
-  scoped_ptr<LayerImpl> layer_impl =
-      ReuseOrCreateLayerImpl(new_layers, old_layers, layer, tree_impl);
+  scoped_ptr<LayerImpl> layer_impl(
+      ReuseOrCreateLayerImpl(old_layers, layer, tree_impl));
 
-  layer_impl->ClearChildList();
+  layer_impl->children().clear();
   for (size_t i = 0; i < layer->children().size(); ++i) {
     layer_impl->AddChild(SynchronizeTreesRecursiveInternal(
-        new_layers, old_layers, layer->child_at(i), tree_impl));
+        old_layers, layer->child_at(i), tree_impl));
   }
 
-  layer_impl->SetMaskLayer(SynchronizeTreesRecursiveInternal(
-      new_layers, old_layers, layer->mask_layer(), tree_impl));
-  layer_impl->SetReplicaLayer(SynchronizeTreesRecursiveInternal(
-      new_layers, old_layers, layer->replica_layer(), tree_impl));
+  scoped_ptr<LayerImpl> mask_layer = SynchronizeTreesRecursiveInternal(
+      old_layers, layer->mask_layer(), tree_impl);
+  if (layer_impl->mask_layer() && mask_layer &&
+      layer_impl->mask_layer() == mask_layer.get()) {
+    // In this case, we only need to update the ownership, as we're essentially
+    // just resetting the mask layer.
+    tree_impl->AddLayer(std::move(mask_layer));
+  } else {
+    layer_impl->SetMaskLayer(std::move(mask_layer));
+  }
+
+  scoped_ptr<LayerImpl> replica_layer = SynchronizeTreesRecursiveInternal(
+      old_layers, layer->replica_layer(), tree_impl);
+  if (layer_impl->replica_layer() && replica_layer &&
+      layer_impl->replica_layer() == replica_layer.get()) {
+    // In this case, we only need to update the ownership, as we're essentially
+    // just resetting the replica layer.
+    tree_impl->AddLayer(std::move(replica_layer));
+  } else {
+    layer_impl->SetReplicaLayer(std::move(replica_layer));
+  }
 
   return layer_impl;
 }
 
-scoped_ptr<LayerImpl> SynchronizeTreesRecursive(
-    RawPtrLayerImplMap* new_layers,
-    ScopedPtrLayerImplMap* old_layers,
-    Layer* layer,
-    LayerTreeImpl* tree_impl) {
-  return SynchronizeTreesRecursiveInternal(
-      new_layers, old_layers, layer, tree_impl);
+void SynchronizeTreesRecursive(OwnedLayerImplMap* old_layers,
+                               Layer* old_root,
+                               LayerTreeImpl* tree_impl) {
+  tree_impl->SetRootLayer(
+      SynchronizeTreesRecursiveInternal(old_layers, old_root, tree_impl));
 }
 
-scoped_ptr<LayerImpl> SynchronizeTreesRecursive(
-    RawPtrLayerImplMap* new_layers,
-    ScopedPtrLayerImplMap* old_layers,
-    LayerImpl* layer,
-    LayerTreeImpl* tree_impl) {
-  return SynchronizeTreesRecursiveInternal(
-      new_layers, old_layers, layer, tree_impl);
+void SynchronizeTreesRecursive(OwnedLayerImplMap* old_layers,
+                               LayerImpl* old_root,
+                               LayerTreeImpl* tree_impl) {
+  tree_impl->SetRootLayer(
+      SynchronizeTreesRecursiveInternal(old_layers, old_root, tree_impl));
 }
 
 static void CheckScrollAndClipPointersRecursive(Layer* layer,
@@ -155,28 +148,24 @@ static void CheckScrollAndClipPointersRecursive(Layer* layer,
 
   if (layer_impl->scroll_children()) {
     for (std::set<Layer*>::iterator it = layer->scroll_children()->begin();
-         it != layer->scroll_children()->end();
-         ++it) {
+         it != layer->scroll_children()->end(); ++it) {
       DCHECK_EQ((*it)->scroll_parent(), layer);
     }
     for (std::set<LayerImpl*>::iterator it =
              layer_impl->scroll_children()->begin();
-         it != layer_impl->scroll_children()->end();
-         ++it) {
+         it != layer_impl->scroll_children()->end(); ++it) {
       DCHECK_EQ((*it)->scroll_parent(), layer_impl);
     }
   }
 
   if (layer_impl->clip_children()) {
     for (std::set<Layer*>::iterator it = layer->clip_children()->begin();
-         it != layer->clip_children()->end();
-         ++it) {
+         it != layer->clip_children()->end(); ++it) {
       DCHECK_EQ((*it)->clip_parent(), layer);
     }
     for (std::set<LayerImpl*>::iterator it =
              layer_impl->clip_children()->begin();
-         it != layer_impl->clip_children()->end();
-         ++it) {
+         it != layer_impl->clip_children()->end(); ++it) {
       DCHECK_EQ((*it)->clip_parent(), layer_impl);
     }
   }
diff --git a/cc/trees/tree_synchronizer.h b/cc/trees/tree_synchronizer.h
index 3c87374..260bd7b 100644
--- a/cc/trees/tree_synchronizer.h
+++ b/cc/trees/tree_synchronizer.h
@@ -21,14 +21,9 @@ class CC_EXPORT TreeSynchronizer {
   // Accepts a Layer tree and returns a reference to a LayerImpl tree that
   // duplicates the structure of the Layer tree, reusing the LayerImpls in the
   // tree provided by old_layer_impl_root if possible.
-  static scoped_ptr<LayerImpl> SynchronizeTrees(
-      Layer* layer_root,
-      scoped_ptr<LayerImpl> old_layer_impl_root,
-      LayerTreeImpl* tree_impl);
-  static scoped_ptr<LayerImpl> SynchronizeTrees(
-      LayerImpl* layer_root,
-      scoped_ptr<LayerImpl> old_layer_impl_root,
-      LayerTreeImpl* tree_impl);
+  static void SynchronizeTrees(Layer* layer_root, LayerTreeImpl* tree_impl);
+  static void SynchronizeTrees(LayerImpl* layer_root, LayerTreeImpl* tree_impl);
+
   static void PushLayerProperties(LayerTreeImpl* pending_tree,
                                   LayerTreeImpl* active_tree);
   static void PushLayerProperties(LayerTreeHost* host_tree,
diff --git a/cc/trees/tree_synchronizer_unittest.cc b/cc/trees/tree_synchronizer_unittest.cc
index 4e30719..4b958de 100644
--- a/cc/trees/tree_synchronizer_unittest.cc
+++ b/cc/trees/tree_synchronizer_unittest.cc
@@ -45,8 +45,7 @@ class MockLayerImpl : public LayerImpl {
 
  private:
   MockLayerImpl(LayerTreeImpl* tree_impl, int layer_id)
-      : LayerImpl(tree_impl, layer_id),
-        layer_impl_destruction_list_(NULL) {}
+      : LayerImpl(tree_impl, layer_id), layer_impl_destruction_list_(NULL) {}
 
   std::vector<int>* layer_impl_destruction_list_;
 };
@@ -92,19 +91,19 @@ void ExpectTreesAreIdentical(Layer* layer,
   ASSERT_EQ(!!layer->mask_layer(), !!layer_impl->mask_layer());
   if (layer->mask_layer()) {
     SCOPED_TRACE("mask_layer");
-    ExpectTreesAreIdentical(
-        layer->mask_layer(), layer_impl->mask_layer(), tree_impl);
+    ExpectTreesAreIdentical(layer->mask_layer(), layer_impl->mask_layer(),
+                            tree_impl);
   }
 
   ASSERT_EQ(!!layer->replica_layer(), !!layer_impl->replica_layer());
   if (layer->replica_layer()) {
     SCOPED_TRACE("replica_layer");
-    ExpectTreesAreIdentical(
-        layer->replica_layer(), layer_impl->replica_layer(), tree_impl);
+    ExpectTreesAreIdentical(layer->replica_layer(), layer_impl->replica_layer(),
+                            tree_impl);
   }
 
   const LayerList& layer_children = layer->children();
-  const OwnedLayerImplList& layer_impl_children = layer_impl->children();
+  const LayerImplList& layer_impl_children = layer_impl->children();
 
   ASSERT_EQ(layer_children.size(), layer_impl_children.size());
 
@@ -115,9 +114,8 @@ void ExpectTreesAreIdentical(Layer* layer,
   ASSERT_EQ(!!layer_scroll_children, !!layer_impl_scroll_children);
 
   if (layer_scroll_children) {
-    ASSERT_EQ(
-        layer_scroll_children->size(),
-        layer_impl_scroll_children->size());
+    ASSERT_EQ(layer_scroll_children->size(),
+              layer_impl_scroll_children->size());
   }
 
   const Layer* layer_scroll_parent = layer->scroll_parent();
@@ -128,9 +126,9 @@ void ExpectTreesAreIdentical(Layer* layer,
   if (layer_scroll_parent) {
     ASSERT_EQ(layer_scroll_parent->id(), layer_impl_scroll_parent->id());
     ASSERT_TRUE(layer_scroll_parent->scroll_children()->find(layer) !=
-        layer_scroll_parent->scroll_children()->end());
+                layer_scroll_parent->scroll_children()->end());
     ASSERT_TRUE(layer_impl_scroll_parent->scroll_children()->find(layer_impl) !=
-        layer_impl_scroll_parent->scroll_children()->end());
+                layer_impl_scroll_parent->scroll_children()->end());
   }
 
   const std::set<Layer*>* layer_clip_children = layer->clip_children();
@@ -150,8 +148,7 @@ void ExpectTreesAreIdentical(Layer* layer,
   if (layer_clip_parent) {
     const std::set<LayerImpl*>* clip_children_impl =
         layer_impl_clip_parent->clip_children();
-    const std::set<Layer*>* clip_children =
-        layer_clip_parent->clip_children();
+    const std::set<Layer*>* clip_children = layer_clip_parent->clip_children();
     ASSERT_EQ(layer_clip_parent->id(), layer_impl_clip_parent->id());
     ASSERT_TRUE(clip_children->find(layer) != clip_children->end());
     ASSERT_TRUE(clip_children_impl->find(layer_impl) !=
@@ -160,8 +157,8 @@ void ExpectTreesAreIdentical(Layer* layer,
 
   for (size_t i = 0; i < layer_children.size(); ++i) {
     SCOPED_TRACE(base::StringPrintf("child layer %" PRIuS, i).c_str());
-    ExpectTreesAreIdentical(layer_children[i].get(),
-                            layer_impl_children[i].get(), tree_impl);
+    ExpectTreesAreIdentical(layer_children[i].get(), layer_impl_children[i],
+                            tree_impl);
   }
 }
 
@@ -198,11 +195,9 @@ class TreeSynchronizerTest : public testing::Test {
 // Attempts to synchronizes a null tree. This should not crash, and should
 // return a null tree.
 TEST_F(TreeSynchronizerTest, SyncNullTree) {
-  scoped_ptr<LayerImpl> layer_impl_tree_root =
-      TreeSynchronizer::SynchronizeTrees(
-          static_cast<Layer*>(NULL), nullptr, host_->active_tree());
-
-  EXPECT_TRUE(!layer_impl_tree_root.get());
+  TreeSynchronizer::SynchronizeTrees(static_cast<Layer*>(NULL),
+                                     host_->active_tree());
+  EXPECT_TRUE(!host_->active_tree()->root_layer());
 }
 
 // Constructs a very simple tree and synchronizes it without trying to reuse any
@@ -214,12 +209,11 @@ TEST_F(TreeSynchronizerTest, SyncSimpleTreeFromEmpty) {
 
   host_->SetRootLayer(layer_tree_root);
 
-  scoped_ptr<LayerImpl> layer_impl_tree_root =
-      TreeSynchronizer::SynchronizeTrees(
-          layer_tree_root.get(), nullptr, host_->active_tree());
+  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
+                                     host_->active_tree());
 
   ExpectTreesAreIdentical(layer_tree_root.get(),
-                          layer_impl_tree_root.get(),
+                          host_->active_tree()->root_layer(),
                           host_->active_tree());
 }
 
@@ -235,11 +229,10 @@ TEST_F(TreeSynchronizerTest, SyncSimpleTreeReusingLayers) {
 
   host_->SetRootLayer(layer_tree_root);
 
-  scoped_ptr<LayerImpl> layer_impl_tree_root =
-      TreeSynchronizer::SynchronizeTrees(
-          layer_tree_root.get(), nullptr, host_->active_tree());
-  ExpectTreesAreIdentical(layer_tree_root.get(),
-                          layer_impl_tree_root.get(),
+  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
+                                     host_->active_tree());
+  LayerImpl* layer_impl_tree_root = host_->active_tree()->root_layer();
+  ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // We have to push properties to pick up the destruction list pointer.
@@ -255,15 +248,17 @@ TEST_F(TreeSynchronizerTest, SyncSimpleTreeReusingLayers) {
 
   // Synchronize again. After the sync the trees should be equivalent and we
   // should have created and destroyed one LayerImpl.
-  layer_impl_tree_root = TreeSynchronizer::SynchronizeTrees(
-      layer_tree_root.get(), std::move(layer_impl_tree_root),
-      host_->active_tree());
-  ExpectTreesAreIdentical(layer_tree_root.get(),
-                          layer_impl_tree_root.get(),
+  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
+                                     host_->active_tree());
+  layer_impl_tree_root = host_->active_tree()->root_layer();
+
+  ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   ASSERT_EQ(1u, layer_impl_destruction_list.size());
   EXPECT_EQ(second_layer_impl_id, layer_impl_destruction_list[0]);
+
+  host_->active_tree()->ClearLayers();
 }
 
 // Constructs a very simple tree and checks that a stacking-order change is
@@ -281,8 +276,8 @@ TEST_F(TreeSynchronizerTest, SyncSimpleTreeAndTrackStackingOrderChange) {
 
   host_->SetRootLayer(layer_tree_root);
 
-  host_->active_tree()->SetRootLayer(TreeSynchronizer::SynchronizeTrees(
-      layer_tree_root.get(), nullptr, host_->active_tree()));
+  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
+                                     host_->active_tree());
   LayerImpl* layer_impl_tree_root = host_->active_tree()->root_layer();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
@@ -297,9 +292,8 @@ TEST_F(TreeSynchronizerTest, SyncSimpleTreeAndTrackStackingOrderChange) {
   // re-insert the layer and sync again.
   child2->RemoveFromParent();
   layer_tree_root->AddChild(child2);
-  host_->active_tree()->SetRootLayer(TreeSynchronizer::SynchronizeTrees(
-      layer_tree_root.get(), host_->active_tree()->DetachLayerTree(),
-      host_->active_tree()));
+  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
+                                     host_->active_tree());
   layer_impl_tree_root = host_->active_tree()->root_layer();
   ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
@@ -311,7 +305,7 @@ TEST_F(TreeSynchronizerTest, SyncSimpleTreeAndTrackStackingOrderChange) {
   EXPECT_FALSE(layer_impl_tree_root->LayerPropertyChanged());
   EXPECT_FALSE(layer_impl_tree_root->children()[0]->LayerPropertyChanged());
   EXPECT_TRUE(layer_impl_tree_root->children()[1]->LayerPropertyChanged());
-  host_->active_tree()->DetachLayerTree();
+  host_->active_tree()->ClearLayers();
 }
 
 TEST_F(TreeSynchronizerTest, SyncSimpleTreeAndProperties) {
@@ -333,11 +327,10 @@ TEST_F(TreeSynchronizerTest, SyncSimpleTreeAndProperties) {
   layer_tree_root->children()[1]->SetBounds(second_child_bounds);
   layer_tree_root->children()[1]->SavePaintProperties();
 
-  scoped_ptr<LayerImpl> layer_impl_tree_root =
-      TreeSynchronizer::SynchronizeTrees(
-          layer_tree_root.get(), nullptr, host_->active_tree());
-  ExpectTreesAreIdentical(layer_tree_root.get(),
-                          layer_impl_tree_root.get(),
+  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
+                                     host_->active_tree());
+  LayerImpl* layer_impl_tree_root = host_->active_tree()->root_layer();
+  ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(),
@@ -371,23 +364,22 @@ TEST_F(TreeSynchronizerTest, ReuseLayerImplsAfterStructuralChange) {
       MockLayer::Create(&layer_impl_destruction_list);
   layer_tree_root->AddChild(MockLayer::Create(&layer_impl_destruction_list));
 
-  scoped_refptr<Layer> layer_a = layer_tree_root->children()[0].get();
+  scoped_refptr<Layer> layer_a = layer_tree_root->children()[0];
   layer_a->AddChild(MockLayer::Create(&layer_impl_destruction_list));
 
-  scoped_refptr<Layer> layer_b = layer_a->children()[0].get();
+  scoped_refptr<Layer> layer_b = layer_a->children()[0];
   layer_b->AddChild(MockLayer::Create(&layer_impl_destruction_list));
 
-  scoped_refptr<Layer> layer_c = layer_b->children()[0].get();
+  scoped_refptr<Layer> layer_c = layer_b->children()[0];
   layer_b->AddChild(MockLayer::Create(&layer_impl_destruction_list));
-  scoped_refptr<Layer> layer_d = layer_b->children()[1].get();
+  scoped_refptr<Layer> layer_d = layer_b->children()[1];
 
   host_->SetRootLayer(layer_tree_root);
 
-  scoped_ptr<LayerImpl> layer_impl_tree_root =
-      TreeSynchronizer::SynchronizeTrees(
-          layer_tree_root.get(), nullptr, host_->active_tree());
-  ExpectTreesAreIdentical(layer_tree_root.get(),
-                          layer_impl_tree_root.get(),
+  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
+                                     host_->active_tree());
+  LayerImpl* layer_impl_tree_root = host_->active_tree()->root_layer();
+  ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // We have to push properties to pick up the destruction list pointer.
@@ -410,14 +402,15 @@ TEST_F(TreeSynchronizerTest, ReuseLayerImplsAfterStructuralChange) {
 
   // After another synchronize our trees should match and we should not have
   // destroyed any LayerImpls
-  layer_impl_tree_root = TreeSynchronizer::SynchronizeTrees(
-      layer_tree_root.get(), std::move(layer_impl_tree_root),
-      host_->active_tree());
-  ExpectTreesAreIdentical(layer_tree_root.get(),
-                          layer_impl_tree_root.get(),
+  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
+                                     host_->active_tree());
+  layer_impl_tree_root = host_->active_tree()->root_layer();
+  ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   EXPECT_EQ(0u, layer_impl_destruction_list.size());
+
+  host_->active_tree()->ClearLayers();
 }
 
 // Constructs a very simple tree, synchronizes it, then synchronizes to a
@@ -438,11 +431,10 @@ TEST_F(TreeSynchronizerTest, SyncSimpleTreeThenDestroy) {
   int old_tree_first_child_layer_id = old_layer_tree_root->children()[0]->id();
   int old_tree_second_child_layer_id = old_layer_tree_root->children()[1]->id();
 
-  scoped_ptr<LayerImpl> layer_impl_tree_root =
-      TreeSynchronizer::SynchronizeTrees(
-          old_layer_tree_root.get(), nullptr, host_->active_tree());
-  ExpectTreesAreIdentical(old_layer_tree_root.get(),
-                          layer_impl_tree_root.get(),
+  TreeSynchronizer::SynchronizeTrees(old_layer_tree_root.get(),
+                                     host_->active_tree());
+  LayerImpl* layer_impl_tree_root = host_->active_tree()->root_layer();
+  ExpectTreesAreIdentical(old_layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // We have to push properties to pick up the destruction list pointer.
@@ -456,11 +448,11 @@ TEST_F(TreeSynchronizerTest, SyncSimpleTreeThenDestroy) {
   // be deleted.
   scoped_refptr<Layer> new_layer_tree_root = Layer::Create();
   host_->SetRootLayer(new_layer_tree_root);
-  layer_impl_tree_root = TreeSynchronizer::SynchronizeTrees(
-      new_layer_tree_root.get(), std::move(layer_impl_tree_root),
-      host_->active_tree());
-  ExpectTreesAreIdentical(new_layer_tree_root.get(),
-                          layer_impl_tree_root.get(),
+
+  TreeSynchronizer::SynchronizeTrees(new_layer_tree_root.get(),
+                                     host_->active_tree());
+  layer_impl_tree_root = host_->active_tree()->root_layer();
+  ExpectTreesAreIdentical(new_layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   ASSERT_EQ(3u, layer_impl_destruction_list.size());
@@ -498,55 +490,53 @@ TEST_F(TreeSynchronizerTest, SyncMaskReplicaAndReplicaMaskLayers) {
   scoped_refptr<Layer> replica_layer_with_mask = Layer::Create();
   scoped_refptr<Layer> replica_mask_layer = Layer::Create();
   replica_layer_with_mask->SetMaskLayer(replica_mask_layer.get());
-  layer_tree_root->children()[2]->
-      SetReplicaLayer(replica_layer_with_mask.get());
+  layer_tree_root->children()[2]->SetReplicaLayer(
+      replica_layer_with_mask.get());
 
   host_->SetRootLayer(layer_tree_root);
 
-  scoped_ptr<LayerImpl> layer_impl_tree_root =
-      TreeSynchronizer::SynchronizeTrees(
-          layer_tree_root.get(), nullptr, host_->active_tree());
-
-  ExpectTreesAreIdentical(layer_tree_root.get(),
-                          layer_impl_tree_root.get(),
+  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
+                                     host_->active_tree());
+  LayerImpl* layer_impl_tree_root = host_->active_tree()->root_layer();
+  ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // Remove the mask layer.
   layer_tree_root->children()[0]->SetMaskLayer(NULL);
-  layer_impl_tree_root = TreeSynchronizer::SynchronizeTrees(
-      layer_tree_root.get(), std::move(layer_impl_tree_root),
-      host_->active_tree());
-  ExpectTreesAreIdentical(layer_tree_root.get(),
-                          layer_impl_tree_root.get(),
+  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
+                                     host_->active_tree());
+  layer_impl_tree_root = host_->active_tree()->root_layer();
+  ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // Remove the replica layer.
   layer_tree_root->children()[1]->SetReplicaLayer(NULL);
-  layer_impl_tree_root = TreeSynchronizer::SynchronizeTrees(
-      layer_tree_root.get(), std::move(layer_impl_tree_root),
-      host_->active_tree());
-  ExpectTreesAreIdentical(layer_tree_root.get(),
-                          layer_impl_tree_root.get(),
+  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
+                                     host_->active_tree());
+  layer_impl_tree_root = host_->active_tree()->root_layer();
+  ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
 
   // Remove the replica mask.
   replica_layer_with_mask->SetMaskLayer(NULL);
-  layer_impl_tree_root = TreeSynchronizer::SynchronizeTrees(
-      layer_tree_root.get(), std::move(layer_impl_tree_root),
-      host_->active_tree());
-  ExpectTreesAreIdentical(layer_tree_root.get(),
-                          layer_impl_tree_root.get(),
+  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
+                                     host_->active_tree());
+  layer_impl_tree_root = host_->active_tree()->root_layer();
+  ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_->active_tree());
+
+  host_->active_tree()->ClearLayers();
 }
 
 TEST_F(TreeSynchronizerTest, SynchronizeScrollParent) {
   LayerTreeSettings settings;
   FakeImplTaskRunnerProvider task_runner_provider;
   FakeRenderingStatsInstrumentation stats_instrumentation;
+  FakeLayerTreeHostImplClient impl_client;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   scoped_ptr<LayerTreeHostImpl> host_impl = LayerTreeHostImpl::Create(
-      settings, nullptr, &task_runner_provider, &stats_instrumentation,
+      settings, &impl_client, &task_runner_provider, &stats_instrumentation,
       &shared_bitmap_manager, nullptr, &task_graph_runner, 0);
 
   scoped_refptr<Layer> layer_tree_root = Layer::Create();
@@ -561,29 +551,26 @@ TEST_F(TreeSynchronizerTest, SynchronizeScrollParent) {
   layer_tree_root->children()[1]->SetScrollParent(scroll_parent.get());
   layer_tree_root->children()[2]->SetScrollParent(scroll_parent.get());
 
-  scoped_ptr<LayerImpl> layer_impl_tree_root =
-      TreeSynchronizer::SynchronizeTrees(
-          layer_tree_root.get(), nullptr, host_impl->active_tree());
+  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
+                                     host_impl->active_tree());
+  LayerImpl* layer_impl_tree_root = host_impl->active_tree()->root_layer();
   TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(),
                                         host_impl->active_tree());
   {
     SCOPED_TRACE("case one");
-    ExpectTreesAreIdentical(layer_tree_root.get(),
-                            layer_impl_tree_root.get(),
+    ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                             host_impl->active_tree());
   }
 
   // Remove the first scroll child.
   layer_tree_root->children()[1]->RemoveFromParent();
-  layer_impl_tree_root = TreeSynchronizer::SynchronizeTrees(
-      layer_tree_root.get(), std::move(layer_impl_tree_root),
-      host_impl->active_tree());
+  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
+                                     host_impl->active_tree());
   TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(),
                                         host_impl->active_tree());
   {
     SCOPED_TRACE("case two");
-    ExpectTreesAreIdentical(layer_tree_root.get(),
-                            layer_impl_tree_root.get(),
+    ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                             host_impl->active_tree());
   }
 
@@ -591,15 +578,13 @@ TEST_F(TreeSynchronizerTest, SynchronizeScrollParent) {
   scoped_refptr<Layer> additional_scroll_child = Layer::Create();
   layer_tree_root->AddChild(additional_scroll_child);
   additional_scroll_child->SetScrollParent(scroll_parent.get());
-  layer_impl_tree_root = TreeSynchronizer::SynchronizeTrees(
-      layer_tree_root.get(), std::move(layer_impl_tree_root),
-      host_impl->active_tree());
+  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
+                                     host_impl->active_tree());
   TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(),
                                         host_impl->active_tree());
   {
     SCOPED_TRACE("case three");
-    ExpectTreesAreIdentical(layer_tree_root.get(),
-                            layer_impl_tree_root.get(),
+    ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                             host_impl->active_tree());
   }
 }
@@ -608,10 +593,11 @@ TEST_F(TreeSynchronizerTest, SynchronizeClipParent) {
   LayerTreeSettings settings;
   FakeImplTaskRunnerProvider task_runner_provider;
   FakeRenderingStatsInstrumentation stats_instrumentation;
+  FakeLayerTreeHostImplClient impl_client;
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
   scoped_ptr<LayerTreeHostImpl> host_impl = LayerTreeHostImpl::Create(
-      settings, nullptr, &task_runner_provider, &stats_instrumentation,
+      settings, &impl_client, &task_runner_provider, &stats_instrumentation,
       &shared_bitmap_manager, nullptr, &task_graph_runner, 0);
 
   scoped_refptr<Layer> layer_tree_root = Layer::Create();
@@ -630,51 +616,44 @@ TEST_F(TreeSynchronizerTest, SynchronizeClipParent) {
   clip_child1->SetClipParent(clip_parent.get());
   clip_child2->SetClipParent(clip_parent.get());
 
-  scoped_ptr<LayerImpl> layer_impl_tree_root =
-      TreeSynchronizer::SynchronizeTrees(
-          layer_tree_root.get(), nullptr, host_impl->active_tree());
+  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
+                                     host_impl->active_tree());
+  LayerImpl* layer_impl_tree_root = host_impl->active_tree()->root_layer();
   TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(),
                                         host_impl->active_tree());
-  ExpectTreesAreIdentical(layer_tree_root.get(),
-                          layer_impl_tree_root.get(),
+  ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_impl->active_tree());
 
   // Remove the first clip child.
   clip_child1->RemoveFromParent();
   clip_child1 = NULL;
 
-  layer_impl_tree_root = TreeSynchronizer::SynchronizeTrees(
-      layer_tree_root.get(), std::move(layer_impl_tree_root),
-      host_impl->active_tree());
+  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
+                                     host_impl->active_tree());
   TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(),
                                         host_impl->active_tree());
-  ExpectTreesAreIdentical(layer_tree_root.get(),
-                          layer_impl_tree_root.get(),
+  ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_impl->active_tree());
 
   // Add an additional clip child.
   scoped_refptr<Layer> additional_clip_child = Layer::Create();
   intervening->AddChild(additional_clip_child);
   additional_clip_child->SetClipParent(clip_parent.get());
-  layer_impl_tree_root = TreeSynchronizer::SynchronizeTrees(
-      layer_tree_root.get(), std::move(layer_impl_tree_root),
-      host_impl->active_tree());
+  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
+                                     host_impl->active_tree());
   TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(),
                                         host_impl->active_tree());
-  ExpectTreesAreIdentical(layer_tree_root.get(),
-                          layer_impl_tree_root.get(),
+  ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_impl->active_tree());
 
   // Remove the nearest clipping ancestor.
   clip_parent->RemoveFromParent();
   clip_parent = NULL;
-  layer_impl_tree_root = TreeSynchronizer::SynchronizeTrees(
-      layer_tree_root.get(), std::move(layer_impl_tree_root),
-      host_impl->active_tree());
+  TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(),
+                                     host_impl->active_tree());
   TreeSynchronizer::PushLayerProperties(layer_tree_root->layer_tree_host(),
                                         host_impl->active_tree());
-  ExpectTreesAreIdentical(layer_tree_root.get(),
-                          layer_impl_tree_root.get(),
+  ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root,
                           host_impl->active_tree());
 
   // The clip children should have been unhooked.
diff --git a/chrome/browser/android/compositor/compositor_view.cc b/chrome/browser/android/compositor/compositor_view.cc
index 8c9971b..ff253cf 100644
--- a/chrome/browser/android/compositor/compositor_view.cc
+++ b/chrome/browser/android/compositor/compositor_view.cc
@@ -18,7 +18,7 @@
 #include "base/rand_util.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/layers/layer.h"
-#include "cc/layers/layer_lists.h"
+#include "cc/layers/layer_collections.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/layers/texture_layer.h"
 #include "chrome/browser/android/compositor/layer/toolbar_layer.h"
diff --git a/chrome/browser/android/compositor/compositor_view.h b/chrome/browser/android/compositor/compositor_view.h
index 1d7f4bb..3b06e2b 100644
--- a/chrome/browser/android/compositor/compositor_view.h
+++ b/chrome/browser/android/compositor/compositor_view.h
@@ -12,7 +12,7 @@
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
-#include "cc/layers/layer_lists.h"
+#include "cc/layers/layer_collections.h"
 #include "cc/resources/ui_resource_client.h"
 #include "content/public/browser/android/compositor_client.h"
 #include "content/public/browser/browser_child_process_observer.h"
diff --git a/chrome/browser/android/compositor/layer/content_layer.cc b/chrome/browser/android/compositor/layer/content_layer.cc
index 5792883..16e67e9 100644
--- a/chrome/browser/android/compositor/layer/content_layer.cc
+++ b/chrome/browser/android/compositor/layer/content_layer.cc
@@ -6,7 +6,7 @@
 
 #include "base/lazy_instance.h"
 #include "cc/layers/layer.h"
-#include "cc/layers/layer_lists.h"
+#include "cc/layers/layer_collections.h"
 #include "chrome/browser/android/compositor/layer/thumbnail_layer.h"
 #include "chrome/browser/android/compositor/tab_content_manager.h"
 #include "content/public/browser/android/compositor.h"
diff --git a/chrome/browser/android/compositor/layer/tab_layer.cc b/chrome/browser/android/compositor/layer/tab_layer.cc
index dcdc3d8..b091a49 100644
--- a/chrome/browser/android/compositor/layer/tab_layer.cc
+++ b/chrome/browser/android/compositor/layer/tab_layer.cc
@@ -6,7 +6,7 @@
 
 #include "base/i18n/rtl.h"
 #include "cc/layers/layer.h"
-#include "cc/layers/layer_lists.h"
+#include "cc/layers/layer_collections.h"
 #include "cc/layers/nine_patch_layer.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/layers/ui_resource_layer.h"