cc: Consolidate LayerList types.

We currently have Layer::LayerList, LayerImpl::LayerList,
LayerTreeHost::LayerList and LayerTreeHostImpl::LayerList,
as well as LayerTreeImpl::LayerList, LayerSorter::LayerList,
and I think some more.

This patch consolidates the list typedefs into three types:
LayerList, LayerImplList, and OwnedLayerImplList.

LayerList and LayerImplList are the output of
CalculateDrawProperties. While OwnedLayerImplList is a list
that owns the layer pointers in it, ie ScopedPtrVector.

R=jamesr

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

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@191442 0039d316-1c4b-4281-b951-d872f2087c98

42 files changed, 197 insertions, 155 deletions

diff --git a/cc/cc.gyp b/cc/cc.gyp
index 990d74b..329f237 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -108,6 +108,7 @@
       'layers/layer_impl.h',
       'layers/layer_iterator.cc',
       'layers/layer_iterator.h',
+      'layers/layer_lists.h',
       'resources/layer_painter.h',
       'resources/layer_quad.cc',
       'resources/layer_quad.h',
diff --git a/cc/debug/debug_rect_history.cc b/cc/debug/debug_rect_history.cc
index 6433d8b..7eaf6ab 100644
--- a/cc/debug/debug_rect_history.cc
+++ b/cc/debug/debug_rect_history.cc
@@ -6,6 +6,7 @@
 
 #include "cc/base/math_util.h"
 #include "cc/layers/layer_impl.h"
+#include "cc/layers/render_surface_impl.h"
 #include "cc/trees/damage_tracker.h"
 #include "cc/trees/layer_tree_host.h"
 
@@ -22,7 +23,7 @@ DebugRectHistory::~DebugRectHistory() {}
 
 void DebugRectHistory::SaveDebugRectsForCurrentFrame(
     LayerImpl* root_layer,
-    const std::vector<LayerImpl*>& render_surface_layer_list,
+    const LayerImplList& render_surface_layer_list,
     const std::vector<gfx::Rect>& occluding_screen_space_rects,
     const std::vector<gfx::Rect>& non_occluding_screen_space_rects,
     const LayerTreeDebugState& debug_state) {
@@ -73,7 +74,7 @@ void DebugRectHistory::SavePaintRects(LayerImpl* layer) {
 }
 
 void DebugRectHistory::SavePropertyChangedRects(
-    const std::vector<LayerImpl*>& render_surface_layer_list) {
+    const LayerImplList& render_surface_layer_list) {
   for (int surface_index = render_surface_layer_list.size() - 1;
        surface_index >= 0;
        --surface_index) {
@@ -81,7 +82,7 @@ void DebugRectHistory::SavePropertyChangedRects(
     RenderSurfaceImpl* render_surface = render_surface_layer->render_surface();
     DCHECK(render_surface);
 
-    const std::vector<LayerImpl*>& layer_list = render_surface->layer_list();
+    const LayerImplList& layer_list = render_surface->layer_list();
     for (unsigned layer_index = 0;
          layer_index < layer_list.size();
          ++layer_index) {
@@ -107,7 +108,7 @@ void DebugRectHistory::SavePropertyChangedRects(
 }
 
 void DebugRectHistory::SaveSurfaceDamageRects(
-    const std::vector<LayerImpl*>& render_surface_layer_list) {
+    const LayerImplList& render_surface_layer_list) {
   for (int surface_index = render_surface_layer_list.size() - 1;
        surface_index >= 0;
        --surface_index) {
@@ -124,7 +125,7 @@ void DebugRectHistory::SaveSurfaceDamageRects(
 }
 
 void DebugRectHistory::SaveScreenSpaceRects(
-    const std::vector<LayerImpl*>& render_surface_layer_list) {
+    const LayerImplList& render_surface_layer_list) {
   for (int surface_index = render_surface_layer_list.size() - 1;
        surface_index >= 0;
        --surface_index) {
diff --git a/cc/debug/debug_rect_history.h b/cc/debug/debug_rect_history.h
index be98e9d..c95b62e 100644
--- a/cc/debug/debug_rect_history.h
+++ b/cc/debug/debug_rect_history.h
@@ -8,6 +8,7 @@
 #include <vector>
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
+#include "cc/layers/layer_lists.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/rect_f.h"
 
@@ -72,7 +73,7 @@ class DebugRectHistory {
   // reset.
   void SaveDebugRectsForCurrentFrame(
       LayerImpl* root_layer,
-      const std::vector<LayerImpl*>& render_surface_layer_list,
+      const LayerImplList& render_surface_layer_list,
       const std::vector<gfx::Rect>& occluding_screen_space_rects,
       const std::vector<gfx::Rect>& non_occluding_screen_space_rects,
       const LayerTreeDebugState& debug_state);
@@ -84,11 +85,11 @@ class DebugRectHistory {
 
   void SavePaintRects(LayerImpl* layer);
   void SavePropertyChangedRects(
-      const std::vector<LayerImpl*>& render_surface_layer_list);
+      const LayerImplList& render_surface_layer_list);
   void SaveSurfaceDamageRects(
-      const std::vector<LayerImpl*>& render_surface_layer_list);
+      const LayerImplList& render_surface_layer_list);
   void SaveScreenSpaceRects(
-      const std::vector<LayerImpl*>& render_surface_layer_list);
+      const LayerImplList& render_surface_layer_list);
   void SaveOccludingRects(
       const std::vector<gfx::Rect>& occluding_screen_space_rects);
   void SaveNonOccludingRects(
diff --git a/cc/layers/contents_scaling_layer_unittest.cc b/cc/layers/contents_scaling_layer_unittest.cc
index 2010922..4a61b6e 100644
--- a/cc/layers/contents_scaling_layer_unittest.cc
+++ b/cc/layers/contents_scaling_layer_unittest.cc
@@ -47,7 +47,7 @@ class MockContentsScalingLayer : public ContentsScalingLayer {
 };
 
 void CalcDrawProps(Layer* root, float device_scale) {
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   LayerTreeHostCommon::CalculateDrawProperties(
       root,
       gfx::Size(500, 500),
diff --git a/cc/layers/delegated_renderer_layer_impl.h b/cc/layers/delegated_renderer_layer_impl.h
index f48ab74..ec86200 100644
--- a/cc/layers/delegated_renderer_layer_impl.h
+++ b/cc/layers/delegated_renderer_layer_impl.h
@@ -12,6 +12,7 @@
 
 namespace cc {
 class DelegatedFrameData;
+class RenderPassSink;
 
 class CC_EXPORT DelegatedRendererLayerImpl : public LayerImpl {
  public:
diff --git a/cc/layers/layer.cc b/cc/layers/layer.cc
index c5a2ad8..7ccd4a7 100644
--- a/cc/layers/layer.cc
+++ b/cc/layers/layer.cc
@@ -699,6 +699,10 @@ void Layer::CreateRenderSurface() {
   draw_properties_.render_target = this;
 }
 
+void Layer::ClearRenderSurface() {
+  draw_properties_.render_surface.reset();
+}
+
 void Layer::OnOpacityAnimated(float opacity) {
   // This is called due to an ongoing accelerated animation. Since this
   // animation is also being run on the impl thread, there is no need to request
diff --git a/cc/layers/layer.h b/cc/layers/layer.h
index 9827f9b..c128531 100644
--- a/cc/layers/layer.h
+++ b/cc/layers/layer.h
@@ -16,6 +16,7 @@
 #include "cc/base/cc_export.h"
 #include "cc/base/region.h"
 #include "cc/layers/draw_properties.h"
+#include "cc/layers/layer_lists.h"
 #include "cc/layers/render_surface.h"
 #include "cc/trees/occlusion_tracker.h"
 #include "skia/ext/refptr.h"
@@ -51,7 +52,6 @@ struct RenderingStats;
 class CC_EXPORT Layer : public base::RefCounted<Layer>,
                         public LayerAnimationValueObserver {
  public:
-  typedef std::vector<scoped_refptr<Layer> > LayerList;
   enum LayerIdLabels {
     PINCH_ZOOM_ROOT_SCROLL_LAYER_ID = -2,
     INVALID_ID = -1,
@@ -277,8 +277,8 @@ class CC_EXPORT Layer : public base::RefCounted<Layer>,
 
   virtual void PushPropertiesTo(LayerImpl* layer);
 
-  void ClearRenderSurface() { draw_properties_.render_surface.reset(); }
   void CreateRenderSurface();
+  void ClearRenderSurface();
 
   // The contents scale converts from logical, non-page-scaled pixels to target
   // pixels. The contents scale is 1 for the root layer as it is already in
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index da5ca13..34334b1 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -82,7 +82,7 @@ void LayerImpl::AddChild(scoped_ptr<LayerImpl> child) {
 }
 
 scoped_ptr<LayerImpl> LayerImpl::RemoveChild(LayerImpl* child) {
-  for (ScopedPtrVector<LayerImpl>::iterator it = children_.begin();
+  for (OwnedLayerImplList::iterator it = children_.begin();
        it != children_.end();
        ++it) {
     if (*it == child) {
@@ -110,6 +110,10 @@ void LayerImpl::CreateRenderSurface() {
   draw_properties_.render_target = this;
 }
 
+void LayerImpl::ClearRenderSurface() {
+  draw_properties_.render_surface.reset();
+}
+
 scoped_ptr<SharedQuadState> LayerImpl::CreateSharedQuadState() const {
   scoped_ptr<SharedQuadState> state = SharedQuadState::Create();
   state->SetAll(draw_properties_.target_space_transform,
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index ed291a6..49ff6dc 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -17,6 +17,7 @@
 #include "cc/base/scoped_ptr_vector.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/draw_properties.h"
+#include "cc/layers/layer_lists.h"
 #include "cc/layers/render_surface_impl.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/shared_quad_state.h"
@@ -48,8 +49,6 @@ struct AppendQuadsData;
 
 class CC_EXPORT LayerImpl : LayerAnimationValueObserver {
  public:
-  typedef ScopedPtrVector<LayerImpl> LayerList;
-
   static scoped_ptr<LayerImpl> Create(LayerTreeImpl* tree_impl, int id) {
     return make_scoped_ptr(new LayerImpl(tree_impl, id));
   }
@@ -66,8 +65,8 @@ class CC_EXPORT LayerImpl : LayerAnimationValueObserver {
   // Tree structure.
   LayerImpl* parent() { return parent_; }
   const LayerImpl* parent() const { return parent_; }
-  const LayerList& children() const { return children_; }
-  LayerList& children() { return children_; }
+  const OwnedLayerImplList& children() const { return children_; }
+  OwnedLayerImplList& 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);
@@ -192,7 +191,7 @@ class CC_EXPORT LayerImpl : LayerAnimationValueObserver {
   // is responsible for calling set_needs_update_draw_properties on the tree
   // so that its list can be recreated.
   void CreateRenderSurface();
-  void ClearRenderSurface() { draw_properties_.render_surface.reset(); }
+  void ClearRenderSurface();
 
   DrawProperties<LayerImpl, RenderSurfaceImpl>& draw_properties() {
     return draw_properties_;
@@ -425,7 +424,7 @@ class CC_EXPORT LayerImpl : LayerAnimationValueObserver {
 
   // Properties internal to LayerImpl
   LayerImpl* parent_;
-  LayerList children_;
+  OwnedLayerImplList children_;
   // 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_;
diff --git a/cc/layers/layer_iterator.cc b/cc/layers/layer_iterator.cc
index 39e4c2c..6fc9ec1 100644
--- a/cc/layers/layer_iterator.cc
+++ b/cc/layers/layer_iterator.cc
@@ -174,9 +174,6 @@ void LayerIteratorActions::FrontToBack::GoToHighestInSubtree(
   }
 }
 
-typedef std::vector<scoped_refptr<Layer> > LayerList;
-typedef std::vector<LayerImpl*> LayerImplList;
-
 // Declare each of the above functions for Layer and LayerImpl classes
 // so that they are linked.
 template CC_EXPORT void LayerIteratorActions::BackToFront::Begin(
diff --git a/cc/layers/layer_iterator.h b/cc/layers/layer_iterator.h
index bd1d63b..d7b85d4 100644
--- a/cc/layers/layer_iterator.h
+++ b/cc/layers/layer_iterator.h
@@ -18,8 +18,9 @@ namespace cc {
 // See below for details.
 //
 // void DoStuffOnLayers(
-//     const std::vector<scoped_refptr<Layer> >& render_surface_layer_list) {
+//     const LayerList& render_surface_layer_list) {
 //   typedef LayerIterator<Layer,
+//                         LayerList,
 //                         RenderSurface,
 //                         LayerIteratorActions::FrontToBack>
 //       LayerIteratorType;
diff --git a/cc/layers/layer_iterator_unittest.cc b/cc/layers/layer_iterator_unittest.cc
index cb2b5b1..15567e4 100644
--- a/cc/layers/layer_iterator_unittest.cc
+++ b/cc/layers/layer_iterator_unittest.cc
@@ -50,15 +50,15 @@ class TestLayer : public Layer {
   EXPECT_EQ(itself, layer->count_representing_itself_);
 
 typedef LayerIterator<Layer,
-                      std::vector<scoped_refptr<Layer> >,
+                      LayerList,
                       RenderSurface,
                       LayerIteratorActions::FrontToBack> FrontToBack;
 typedef LayerIterator<Layer,
-                      std::vector<scoped_refptr<Layer> >,
+                      LayerList,
                       RenderSurface,
                       LayerIteratorActions::BackToFront> BackToFront;
 
-void ResetCounts(std::vector<scoped_refptr<Layer> >* render_surface_layerList) {
+void ResetCounts(LayerList* render_surface_layerList) {
   for (unsigned surface_index = 0;
        surface_index < render_surface_layerList->size();
        ++surface_index) {
@@ -84,7 +84,7 @@ void ResetCounts(std::vector<scoped_refptr<Layer> >* render_surface_layerList) {
 }
 
 void IterateFrontToBack(
-    std::vector<scoped_refptr<Layer> >* render_surface_layerList) {
+    LayerList* render_surface_layerList) {
   ResetCounts(render_surface_layerList);
   int count = 0;
   for (FrontToBack it = FrontToBack::Begin(render_surface_layerList);
@@ -101,7 +101,7 @@ void IterateFrontToBack(
 }
 
 void IterateBackToFront(
-    std::vector<scoped_refptr<Layer> >* render_surface_layerList) {
+    LayerList* render_surface_layerList) {
   ResetCounts(render_surface_layerList);
   int count = 0;
   for (BackToFront it = BackToFront::Begin(render_surface_layerList);
@@ -118,7 +118,7 @@ void IterateBackToFront(
 }
 
 TEST(LayerIteratorTest, EmptyTree) {
-  std::vector<scoped_refptr<Layer> > render_surface_layerList;
+  LayerList render_surface_layerList;
 
   IterateBackToFront(&render_surface_layerList);
   IterateFrontToBack(&render_surface_layerList);
@@ -138,7 +138,7 @@ TEST(LayerIteratorTest, SimpleTree) {
   root_layer->AddChild(third);
   root_layer->AddChild(fourth);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layerList;
+  LayerList render_surface_layerList;
   LayerTreeHostCommon::CalculateDrawProperties(root_layer.get(),
                                                root_layer->bounds(),
                                                1,
@@ -184,7 +184,7 @@ TEST(LayerIteratorTest, ComplexTree) {
   root22->AddChild(root221);
   root23->AddChild(root231);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layerList;
+  LayerList render_surface_layerList;
   LayerTreeHostCommon::CalculateDrawProperties(root_layer.get(),
                                                root_layer->bounds(),
                                                1,
@@ -245,7 +245,7 @@ TEST(LayerIteratorTest, ComplexTreeMultiSurface) {
   root23->SetOpacity(0.5f);
   root23->AddChild(root231);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layerList;
+  LayerList render_surface_layerList;
   LayerTreeHostCommon::CalculateDrawProperties(root_layer.get(),
                                                root_layer->bounds(),
                                                1,
diff --git a/cc/layers/layer_lists.h b/cc/layers/layer_lists.h
new file mode 100644
index 0000000..83ef5fd
--- /dev/null
+++ b/cc/layers/layer_lists.h
@@ -0,0 +1,24 @@
+// 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 "cc/base/scoped_ptr_vector.h"
+
+namespace cc {
+class Layer;
+class LayerImpl;
+
+typedef std::vector<scoped_refptr<Layer> > LayerList;
+
+typedef ScopedPtrVector<LayerImpl> OwnedLayerImplList;
+typedef std::vector<LayerImpl*> LayerImplList;
+
+}  // namespace cc
+
+#endif  // CC_LAYERS_LAYER_LISTS_H_
diff --git a/cc/layers/layer_unittest.cc b/cc/layers/layer_unittest.cc
index da4283f..89df07b 100644
--- a/cc/layers/layer_unittest.cc
+++ b/cc/layers/layer_unittest.cc
@@ -392,7 +392,7 @@ TEST_F(LayerTest, SetChildren) {
   scoped_refptr<Layer> child1 = Layer::Create();
   scoped_refptr<Layer> child2 = Layer::Create();
 
-  std::vector<scoped_refptr<Layer> > new_children;
+  LayerList new_children;
   new_children.push_back(child1);
   new_children.push_back(child2);
 
diff --git a/cc/layers/render_surface.h b/cc/layers/render_surface.h
index 5e29889..11d7d4e 100644
--- a/cc/layers/render_surface.h
+++ b/cc/layers/render_surface.h
@@ -11,6 +11,7 @@
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "cc/base/cc_export.h"
+#include "cc/layers/layer_lists.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/rect_f.h"
 #include "ui/gfx/transform.h"
@@ -85,7 +86,6 @@ class CC_EXPORT RenderSurface {
   gfx::Rect clip_rect() const { return clip_rect_; }
   void SetClipRect(gfx::Rect clip_rect) { clip_rect_ = clip_rect; }
 
-  typedef std::vector<scoped_refptr<Layer> > LayerList;
   LayerList& layer_list() { return layer_list_; }
   // A no-op since DelegatedRendererLayers on the main thread don't have any
   // RenderPasses so they can't contribute to a surface.
diff --git a/cc/layers/render_surface_impl.h b/cc/layers/render_surface_impl.h
index 5154561..8a7f73f 100644
--- a/cc/layers/render_surface_impl.h
+++ b/cc/layers/render_surface_impl.h
@@ -11,6 +11,7 @@
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/base/cc_export.h"
+#include "cc/layers/layer_lists.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/shared_quad_state.h"
 #include "ui/gfx/rect.h"
@@ -109,7 +110,7 @@ class CC_EXPORT RenderSurfaceImpl {
   void SetContentRect(gfx::Rect content_rect);
   gfx::Rect content_rect() const { return content_rect_; }
 
-  std::vector<LayerImpl*>& layer_list() { return layer_list_; }
+  LayerImplList& layer_list() { return layer_list_; }
   void AddContributingDelegatedRenderPassLayer(LayerImpl* layer);
   void ClearLayerLists();
 
@@ -150,7 +151,7 @@ class CC_EXPORT RenderSurfaceImpl {
   // Uses the space of the surface's target surface.
   gfx::Rect clip_rect_;
 
-  std::vector<LayerImpl*> layer_list_;
+  LayerImplList layer_list_;
   std::vector<DelegatedRendererLayerImpl*>
       contributing_delegated_render_pass_layer_list_;
 
diff --git a/cc/layers/solid_color_layer_impl_unittest.cc b/cc/layers/solid_color_layer_impl_unittest.cc
index e5a9abf..13c9cfb 100644
--- a/cc/layers/solid_color_layer_impl_unittest.cc
+++ b/cc/layers/solid_color_layer_impl_unittest.cc
@@ -109,7 +109,7 @@ TEST(SolidColorLayerImplTest, VerifyOpaqueRect) {
   scoped_refptr<Layer> root = Layer::Create();
   root->AddChild(layer);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   LayerTreeHostCommon::CalculateDrawProperties(
       root, gfx::Size(500, 500), 1, 1, 1024, false, &render_surface_layer_list);
 
diff --git a/cc/layers/tiled_layer_unittest.cc b/cc/layers/tiled_layer_unittest.cc
index 650f1cb..6a8c5b7 100644
--- a/cc/layers/tiled_layer_unittest.cc
+++ b/cc/layers/tiled_layer_unittest.cc
@@ -130,7 +130,7 @@ class TiledLayerTest : public testing::Test {
     if (occlusion_)
       occlusion_->SetRenderTarget(layer_tree_host_->root_layer());
 
-    std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+    LayerList render_surface_layer_list;
     LayerTreeHostCommon::CalculateDrawProperties(
         layer_tree_host_->root_layer(),
         layer_tree_host_->device_viewport_size(),
diff --git a/cc/test/layer_tree_test.cc b/cc/test/layer_tree_test.cc
index e865d29..51a1a61 100644
--- a/cc/test/layer_tree_test.cc
+++ b/cc/test/layer_tree_test.cc
@@ -60,8 +60,6 @@ scoped_refptr<cc::ContextProvider> TestHooks::
 // Adapts LayerTreeHostImpl for test. Runs real code, then invokes test hooks.
 class LayerTreeHostImplForTesting : public LayerTreeHostImpl {
  public:
-  typedef std::vector<LayerImpl*> LayerList;
-
   static scoped_ptr<LayerTreeHostImplForTesting> Create(
       TestHooks* test_hooks,
       const LayerTreeSettings& settings,
diff --git a/cc/trees/damage_tracker.cc b/cc/trees/damage_tracker.cc
index e8343e7..5138e6f 100644
--- a/cc/trees/damage_tracker.cc
+++ b/cc/trees/damage_tracker.cc
@@ -46,7 +46,7 @@ static inline void ExpandDamageRectInsideRectWithFilters(
 }
 
 void DamageTracker::UpdateDamageTrackingState(
-    const std::vector<LayerImpl*>& layer_list,
+    const LayerImplList& layer_list,
     int target_surface_layer_id,
     bool target_surface_property_changed_only_from_descendant,
     gfx::Rect target_surface_content_rect,
@@ -184,7 +184,7 @@ void DamageTracker::SaveRectForNextFrame(int layer_id,
 }
 
 gfx::RectF DamageTracker::TrackDamageFromActiveLayers(
-    const std::vector<LayerImpl*>& layer_list,
+    const LayerImplList& layer_list,
     int target_surface_layer_id) {
   gfx::RectF damage_rect = gfx::RectF();
 
diff --git a/cc/trees/damage_tracker.h b/cc/trees/damage_tracker.h
index a5c1c54..f09fe32 100644
--- a/cc/trees/damage_tracker.h
+++ b/cc/trees/damage_tracker.h
@@ -9,6 +9,7 @@
 #include "base/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/base/cc_export.h"
+#include "cc/layers/layer_lists.h"
 #include "ui/gfx/rect_f.h"
 
 class SkImageFilter;
@@ -37,7 +38,7 @@ class CC_EXPORT DamageTracker {
   void DidDrawDamagedArea() { current_damage_rect_ = gfx::RectF(); }
   void ForceFullDamageNextUpdate() { force_full_damage_next_update_ = true; }
   void UpdateDamageTrackingState(
-      const std::vector<LayerImpl*>& layer_list,
+      const LayerImplList& layer_list,
       int target_surface_layer_id,
       bool target_surface_property_changed_only_from_descendant,
       gfx::Rect target_surface_content_rect,
@@ -51,7 +52,7 @@ class CC_EXPORT DamageTracker {
   DamageTracker();
 
   gfx::RectF TrackDamageFromActiveLayers(
-      const std::vector<LayerImpl*>& layer_list,
+      const LayerImplList& layer_list,
       int target_surface_layer_id);
   gfx::RectF TrackDamageFromSurfaceMask(LayerImpl* target_surface_mask_layer);
   gfx::RectF TrackDamageFromLeftoverRects();
diff --git a/cc/trees/damage_tracker_unittest.cc b/cc/trees/damage_tracker_unittest.cc
index 95d02e8..d46a9a4 100644
--- a/cc/trees/damage_tracker_unittest.cc
+++ b/cc/trees/damage_tracker_unittest.cc
@@ -25,7 +25,7 @@ namespace {
 
 void ExecuteCalculateDrawProperties(
     LayerImpl* root,
-    std::vector<LayerImpl*>& render_surface_layer_list) {
+    LayerImplList& render_surface_layer_list) {
   int dummy_max_texture_size = 512;
 
   // Sanity check: The test itself should create the root layer's render
@@ -60,7 +60,7 @@ void EmulateDrawingOneFrame(LayerImpl* root) {
   //   3. resetting all update_rects and property_changed flags for all layers
   //      and surfaces.
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   ExecuteCalculateDrawProperties(root, render_surface_layer_list);
 
   // Iterate back-to-front, so that damage correctly propagates from descendant
diff --git a/cc/trees/layer_sorter.cc b/cc/trees/layer_sorter.cc
index 51fa4b6..a313f9e 100644
--- a/cc/trees/layer_sorter.cc
+++ b/cc/trees/layer_sorter.cc
@@ -259,12 +259,12 @@ float LayerShape::LayerZFromProjectedPoint(gfx::PointF p) const {
   return n / d;
 }
 
-void LayerSorter::CreateGraphNodes(LayerList::iterator first,
-                                   LayerList::iterator last) {
+void LayerSorter::CreateGraphNodes(LayerImplList::iterator first,
+                                   LayerImplList::iterator last) {
   DVLOG(2) << "Creating graph nodes:";
   float min_z = FLT_MAX;
   float max_z = -FLT_MAX;
-  for (LayerList::const_iterator it = first; it < last; it++) {
+  for (LayerImplList::const_iterator it = first; it < last; it++) {
     nodes_.push_back(GraphNode(*it));
     GraphNode& node = nodes_.at(nodes_.size() - 1);
     RenderSurfaceImpl* render_surface = node.layer->render_surface();
@@ -373,7 +373,8 @@ void LayerSorter::RemoveEdgeFromList(GraphEdge* edge,
 // preserve the ordering of the original list of layers, since that list should
 // already have proper z-index ordering of layers.
 //
-void LayerSorter::Sort(LayerList::iterator first, LayerList::iterator last) {
+void LayerSorter::Sort(LayerImplList::iterator first,
+                       LayerImplList::iterator last) {
   DVLOG(2) << "Sorting start ----";
   CreateGraphNodes(first, last);
 
@@ -454,7 +455,7 @@ void LayerSorter::Sort(LayerList::iterator first, LayerList::iterator last) {
   // ref count go to zero here as they are all nodes of the layer hierarchy and
   // are kept alive by their parent nodes.
   int count = 0;
-  for (LayerList::iterator it = first; it < last; it++)
+  for (LayerImplList::iterator it = first; it < last; it++)
     *it = sorted_list[count++]->layer;
 
   DVLOG(2) << "Sorting end ----";
diff --git a/cc/trees/layer_sorter.h b/cc/trees/layer_sorter.h
index 5577ad7..4bdf77c 100644
--- a/cc/trees/layer_sorter.h
+++ b/cc/trees/layer_sorter.h
@@ -79,9 +79,7 @@ class CC_EXPORT LayerSorter {
   LayerSorter();
   ~LayerSorter();
 
-  typedef std::vector<LayerImpl*> LayerList;
-
-  void Sort(LayerList::iterator first, LayerList::iterator last);
+  void Sort(LayerImplList::iterator first, LayerImplList::iterator last);
 
   enum ABCompareResult {
     ABeforeB,
@@ -104,7 +102,8 @@ class CC_EXPORT LayerSorter {
   typedef base::hash_map<GraphEdge*, GraphEdge*> EdgeMap;
   EdgeMap active_edges_;
 
-  void CreateGraphNodes(LayerList::iterator first, LayerList::iterator last);
+  void CreateGraphNodes(LayerImplList::iterator first,
+                        LayerImplList::iterator last);
   void CreateGraphEdges();
   void RemoveEdgeFromList(GraphEdge* graph, std::vector<GraphEdge*>* list);
 
diff --git a/cc/trees/layer_sorter_unittest.cc b/cc/trees/layer_sorter_unittest.cc
index 73de79c..b1d7b81 100644
--- a/cc/trees/layer_sorter_unittest.cc
+++ b/cc/trees/layer_sorter_unittest.cc
@@ -248,7 +248,7 @@ TEST(LayerSorterTest, VerifyExistingOrderingPreservedWhenNoZDiff) {
   layer5->draw_properties().target_space_transform = BehindMatrix;
   layer5->SetDrawsContent(true);
 
-  std::vector<LayerImpl*> layer_list;
+  LayerImplList layer_list;
   layer_list.push_back(layer1.get());
   layer_list.push_back(layer2.get());
   layer_list.push_back(layer3.get());
@@ -305,7 +305,7 @@ TEST(LayerSorterTest, VerifyConcidentLayerPrecisionLossResultsInDocumentOrder) {
   layer2->draw_properties().target_space_transform = FrontMatrix;
   layer2->SetDrawsContent(true);
 
-  std::vector<LayerImpl*> layer_list;
+  LayerImplList layer_list;
   layer_list.push_back(layer1.get());
   layer_list.push_back(layer2.get());
 
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index 3dd7b4c..bf2d87c 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -26,6 +26,7 @@
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_iterator.h"
+#include "cc/layers/render_surface.h"
 #include "cc/layers/scrollbar_layer.h"
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/trees/layer_tree_host_client.h"
@@ -719,7 +720,8 @@ void LayerTreeHost::UpdateLayers(Layer* root_layer,
                                  ResourceUpdateQueue* queue) {
   TRACE_EVENT0("cc", "LayerTreeHost::UpdateLayers");
 
-  LayerList update_list; {
+  LayerList update_list;
+  {
     Layer* root_scroll = FindFirstScrollableLayer(root_layer);
     if (root_scroll)
       root_scroll->SetImplTransform(impl_transform_);
diff --git a/cc/trees/layer_tree_host.h b/cc/trees/layer_tree_host.h
index b412dab..27c146e 100644
--- a/cc/trees/layer_tree_host.h
+++ b/cc/trees/layer_tree_host.h
@@ -18,6 +18,7 @@
 #include "cc/animation/animation_events.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/scoped_ptr_vector.h"
+#include "cc/layers/layer_lists.h"
 #include "cc/output/output_surface.h"
 #include "cc/scheduler/rate_limiter.h"
 #include "cc/trees/layer_tree_host_client.h"
@@ -249,8 +250,6 @@ class CC_EXPORT LayerTreeHost : NON_EXPORTED_BASE(public RateLimiterClient) {
   bool InitializeForTesting(scoped_ptr<Proxy> proxy_for_testing);
 
  private:
-  typedef std::vector<scoped_refptr<Layer> > LayerList;
-
   bool InitializeProxy(scoped_ptr<Proxy> proxy);
   void InitializeRenderer();
 
diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc
index e5976ce..cf59706 100644
--- a/cc/trees/layer_tree_host_common.cc
+++ b/cc/trees/layer_tree_host_common.cc
@@ -26,14 +26,14 @@ ScrollAndScaleSet::ScrollAndScaleSet() {}
 
 ScrollAndScaleSet::~ScrollAndScaleSet() {}
 
-static void SortLayers(std::vector<scoped_refptr<Layer> >::iterator forst,
-                       std::vector<scoped_refptr<Layer> >::iterator end,
+static void SortLayers(LayerList::iterator forst,
+                       LayerList::iterator end,
                        void* layer_sorter) {
   NOTREACHED();
 }
 
-static void SortLayers(std::vector<LayerImpl*>::iterator first,
-                       std::vector<LayerImpl*>::iterator end,
+static void SortLayers(LayerImplList::iterator first,
+                       LayerImplList::iterator end,
                        LayerSorter* layer_sorter) {
   DCHECK(layer_sorter);
   TRACE_EVENT0("cc", "LayerTreeHostCommon::SortLayers");
@@ -1294,12 +1294,12 @@ void LayerTreeHostCommon::CalculateDrawProperties(
     float page_scale_factor,
     int max_texture_size,
     bool can_use_lcd_text,
-    std::vector<scoped_refptr<Layer> >* render_surface_layer_list) {
+    LayerList* render_surface_layer_list) {
   gfx::Rect total_drawable_content_rect;
   gfx::Transform identity_matrix;
   gfx::Transform device_scale_transform;
   device_scale_transform.Scale(device_scale_factor, device_scale_factor);
-  std::vector<scoped_refptr<Layer> > dummy_layer_list;
+  LayerList dummy_layer_list;
 
   // The root layer's render_surface should receive the device viewport as the
   // initial clip rect.
@@ -1312,7 +1312,7 @@ void LayerTreeHostCommon::CalculateDrawProperties(
 
   PreCalculateMetaInformation<Layer>(root_layer);
   CalculateDrawPropertiesInternal<Layer,
-                                  std::vector<scoped_refptr<Layer> >,
+                                  LayerList,
                                   RenderSurface>(root_layer,
                                                  device_scale_transform,
                                                  identity_matrix,
@@ -1345,13 +1345,13 @@ void LayerTreeHostCommon::CalculateDrawProperties(
     float page_scale_factor,
     int max_texture_size,
     bool can_use_lcd_text,
-    std::vector<LayerImpl*>* render_surface_layer_list,
+    LayerImplList* render_surface_layer_list,
     bool update_tile_priorities) {
   gfx::Rect total_drawable_content_rect;
   gfx::Transform identity_matrix;
   gfx::Transform device_scale_transform;
   device_scale_transform.Scale(device_scale_factor, device_scale_factor);
-  std::vector<LayerImpl*> dummy_layer_list;
+  LayerImplList dummy_layer_list;
   LayerSorter layer_sorter;
 
   // The root layer's render_surface should receive the device viewport as the
@@ -1364,7 +1364,7 @@ void LayerTreeHostCommon::CalculateDrawProperties(
 
   PreCalculateMetaInformation<LayerImpl>(root_layer);
   CalculateDrawPropertiesInternal<LayerImpl,
-                                  std::vector<LayerImpl*>,
+                                  LayerImplList,
                                   RenderSurfaceImpl>(
       root_layer,
       device_scale_transform,
@@ -1483,11 +1483,11 @@ static bool PointIsClippedBySurfaceOrClipRect(gfx::PointF screen_space_point,
 
 LayerImpl* LayerTreeHostCommon::FindLayerThatIsHitByPoint(
     gfx::PointF screen_space_point,
-    const std::vector<LayerImpl*>& render_surface_layer_list) {
+    const LayerImplList& render_surface_layer_list) {
   LayerImpl* found_layer = NULL;
 
   typedef LayerIterator<LayerImpl,
-                        std::vector<LayerImpl*>,
+                        LayerImplList,
                         RenderSurfaceImpl,
                         LayerIteratorActions::FrontToBack> LayerIteratorType;
   LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list);
@@ -1529,11 +1529,11 @@ LayerImpl* LayerTreeHostCommon::FindLayerThatIsHitByPoint(
 
 LayerImpl* LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
     gfx::PointF screen_space_point,
-    const std::vector<LayerImpl*>& render_surface_layer_list) {
+    const LayerImplList& render_surface_layer_list) {
   LayerImpl* found_layer = NULL;
 
   typedef LayerIterator<LayerImpl,
-                        std::vector<LayerImpl*>,
+                        LayerImplList,
                         RenderSurfaceImpl,
                         LayerIteratorActions::FrontToBack> LayerIteratorType;
   LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list);
diff --git a/cc/trees/layer_tree_host_common.h b/cc/trees/layer_tree_host_common.h
index 16bd192..8c15d20 100644
--- a/cc/trees/layer_tree_host_common.h
+++ b/cc/trees/layer_tree_host_common.h
@@ -10,6 +10,7 @@
 #include "base/memory/ref_counted.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/scoped_ptr_vector.h"
+#include "cc/layers/layer_lists.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/vector2d.h"
@@ -32,7 +33,7 @@ class CC_EXPORT LayerTreeHostCommon {
       float page_scale_factor,
       int max_texture_size,
       bool can_use_lcd_text,
-      std::vector<scoped_refptr<Layer> >* render_surface_layer_list);
+      LayerList* render_surface_layer_list);
   static void CalculateDrawProperties(
       LayerImpl* root_layer,
       gfx::Size device_viewport_size,
@@ -40,17 +41,17 @@ class CC_EXPORT LayerTreeHostCommon {
       float page_scale_factor,
       int max_texture_size,
       bool can_use_lcd_text,
-      std::vector<LayerImpl*>* render_surface_layer_list,
+      LayerImplList* render_surface_layer_list,
       bool update_tile_priorities);
 
   // Performs hit testing for a given render_surface_layer_list.
   static LayerImpl* FindLayerThatIsHitByPoint(
       gfx::PointF screen_space_point,
-      const std::vector<LayerImpl*>& render_surface_layer_list);
+      const LayerImplList& render_surface_layer_list);
 
   static LayerImpl* FindLayerThatIsHitByPointInTouchHandlerRegion(
       gfx::PointF screen_space_point,
-      const std::vector<LayerImpl*>& render_surface_layer_list);
+      const LayerImplList& render_surface_layer_list);
 
   static bool LayerHasTouchEventHandlersAt(gfx::PointF screen_space_point,
                                            LayerImpl* layer_impl);
@@ -68,13 +69,13 @@ class CC_EXPORT LayerTreeHostCommon {
   static LayerType* FindLayerInSubtree(LayerType* root_layer, int layer_id);
 
   static Layer* get_child_as_raw_ptr(
-      const std::vector<scoped_refptr<Layer> >& children,
+      const LayerList& children,
       size_t index) {
     return children[index].get();
   }
 
   static LayerImpl* get_child_as_raw_ptr(
-      const ScopedPtrVector<LayerImpl>& children,
+      const OwnedLayerImplList& children,
       size_t index) {
     return children[index];
   }
diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc
index 2959723..18c02eb 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc
@@ -12,6 +12,8 @@
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
+#include "cc/layers/render_surface.h"
+#include "cc/layers/render_surface_impl.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
@@ -84,7 +86,7 @@ void ExecuteCalculateDrawProperties(Layer* root_layer,
                                     float page_scale_factor,
                                     bool can_use_lcd_text) {
   gfx::Transform identity_matrix;
-  std::vector<scoped_refptr<Layer> > dummy_render_surface_layer_list;
+  LayerList dummy_render_surface_layer_list;
   int dummy_max_texture_size = 512;
   gfx::Size device_viewport_size =
       gfx::Size(root_layer->bounds().width() * device_scale_factor,
@@ -108,7 +110,7 @@ void ExecuteCalculateDrawProperties(LayerImpl* root_layer,
                                     float page_scale_factor,
                                     bool can_use_lcd_text) {
   gfx::Transform identity_matrix;
-  std::vector<LayerImpl*> dummy_render_surface_layer_list;
+  LayerImplList dummy_render_surface_layer_list;
   int dummy_max_texture_size = 512;
   gfx::Size device_viewport_size =
       gfx::Size(root_layer->bounds().width() * device_scale_factor,
@@ -1549,7 +1551,7 @@ TEST(LayerTreeHostCommonTest,
   render_surface1->AddChild(child);
   render_surface1->SetForceRenderSurface(true);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
@@ -1596,7 +1598,7 @@ TEST(LayerTreeHostCommonTest, RenderSurfaceListForTransparentChild) {
   render_surface1->SetForceRenderSurface(true);
   render_surface1->SetOpacity(0.f);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
@@ -1653,7 +1655,7 @@ TEST(LayerTreeHostCommonTest, ForceRenderSurface) {
   EXPECT_FALSE(parent->render_surface());
   EXPECT_FALSE(render_surface1->render_surface());
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
@@ -2460,7 +2462,7 @@ TEST(LayerTreeHostCommonTest, ClipRectCullsRenderSurfaces) {
   grand_child->SetOpacity(0.5f);
   great_grand_child->SetOpacity(0.4f);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
@@ -2539,7 +2541,7 @@ TEST(LayerTreeHostCommonTest, ClipRectCullsSurfaceWithoutVisibleContent) {
   grand_child->SetOpacity(0.4f);
   grand_child->SetForceRenderSurface(true);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
@@ -2663,7 +2665,7 @@ TEST(LayerTreeHostCommonTest, IsClippedIsSetCorrectly) {
                                false);
 
   // Case 1: nothing is clipped except the root render surface.
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                parent->bounds(),
@@ -2822,7 +2824,7 @@ TEST(LayerTreeHostCommonTest, drawable_content_rectForLayers) {
   grand_child3->SetOpacity(0.5f);
   grand_child4->SetOpacity(0.5f);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
@@ -2965,7 +2967,7 @@ TEST(LayerTreeHostCommonTest, ClipRectIsPropagatedCorrectlyToSurfaces) {
   grand_child4->SetOpacity(0.5f);
   grand_child4->SetForceRenderSurface(true);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
@@ -4262,7 +4264,7 @@ TEST(LayerTreeHostCommonTest, BackFaceCullingWithoutPreserves3d) {
                                gfx::Size(100, 100),
                                false);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
@@ -4454,7 +4456,7 @@ TEST(LayerTreeHostCommonTest, BackFaceCullingWithPreserves3d) {
                                gfx::Size(100, 100),
                                false);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
@@ -4592,7 +4594,7 @@ TEST(LayerTreeHostCommonTest, BackFaceCullingWithAnimatingTransforms) {
                                gfx::Size(100, 100),
                                false);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
@@ -4718,7 +4720,7 @@ TEST(LayerTreeHostCommonTest,
                                gfx::Size(100, 100),
                                false);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
@@ -4762,7 +4764,7 @@ TEST(LayerTreeHostCommonTest,
 TEST(LayerTreeHostCommonTest, HitTestingForEmptyLayerList) {
   // Hit testing on an empty render_surface_layer_list should return a null
   // pointer.
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
 
   gfx::Point test_point(0, 0);
   LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
@@ -4794,7 +4796,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForSingleLayer) {
                                false);
   root->SetDrawsContent(true);
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
@@ -4869,7 +4871,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForSingleLayerAndHud) {
   host_impl.active_tree()->set_hud_layer(hud.get());
   root->AddChild(hud.PassAs<LayerImpl>());
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                hud_bounds,
@@ -4936,7 +4938,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForUninvertibleTransform) {
                                false);
   root->SetDrawsContent(true);
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
@@ -5012,7 +5014,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForSinglePositionedLayer) {
                                false);
   root->SetDrawsContent(true);
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
@@ -5077,7 +5079,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForSingleRotatedLayer) {
                                false);
   root->SetDrawsContent(true);
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
@@ -5155,7 +5157,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForSinglePerspectiveLayer) {
       false);
   root->SetDrawsContent(true);
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
@@ -5244,7 +5246,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForSingleLayerWithScaledContents) {
     root->AddChild(test_layer.Pass());
   }
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
@@ -5344,7 +5346,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForSimpleClippedLayer) {
     root->AddChild(clipping_layer.Pass());
   }
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
@@ -5477,7 +5479,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForMultiClippedRotatedLayer) {
     root->AddChild(child.Pass());
   }
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
@@ -5603,7 +5605,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForNonClippingIntermediateLayer) {
     root->AddChild(intermediate_layer.Pass());
   }
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
@@ -5720,7 +5722,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForMultipleLayers) {
   LayerImpl* child2 = root->children()[1];
   LayerImpl* grand_child1 = child1->children()[0];
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
@@ -5873,7 +5875,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForMultipleLayerLists) {
   LayerImpl* child2 = root->children()[1];
   LayerImpl* grand_child1 = child1->children()[0];
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
@@ -5955,7 +5957,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForMultipleLayerLists) {
 TEST(LayerTreeHostCommonTest, HitCheckingTouchHandlerRegionsForEmptyLayerList) {
   // Hit checking on an empty render_surface_layer_list should return a null
   // pointer.
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
 
   gfx::Point test_point(0, 0);
   LayerImpl* result_layer =
@@ -5990,7 +5992,7 @@ TEST(LayerTreeHostCommonTest, HitCheckingTouchHandlerRegionsForSingleLayer) {
                                false);
   root->SetDrawsContent(true);
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
@@ -6087,7 +6089,7 @@ TEST(LayerTreeHostCommonTest,
   root->SetDrawsContent(true);
   root->SetTouchEventHandlerRegion(touch_handler_region);
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
@@ -6174,7 +6176,7 @@ TEST(LayerTreeHostCommonTest,
   root->SetDrawsContent(true);
   root->SetTouchEventHandlerRegion(touch_handler_region);
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
@@ -6279,7 +6281,7 @@ TEST(LayerTreeHostCommonTest,
     root->AddChild(test_layer.Pass());
   }
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
@@ -6387,7 +6389,7 @@ TEST(LayerTreeHostCommonTest,
     root->AddChild(test_layer.Pass());
   }
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   float device_scale_factor = 3.f;
   float page_scale_factor = 5.f;
@@ -6534,7 +6536,7 @@ TEST(LayerTreeHostCommonTest,
     root->AddChild(clipping_layer.Pass());
   }
 
-  std::vector<LayerImpl*> render_surface_layer_list;
+  LayerImplList render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(root.get(),
                                                root->bounds(),
@@ -6670,7 +6672,7 @@ TEST(LayerTreeHostCommonTest, LayerTransformsInHighDPI) {
   parent->AddChild(child_empty);
   parent->AddChild(child_no_scale);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
 
   float device_scale_factor = 2.5f;
@@ -6805,7 +6807,7 @@ TEST(LayerTreeHostCommonTest, SurfaceLayerTransformsInHighDPI) {
   parent->AddChild(perspective_surface);
   parent->AddChild(scale_surface);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
 
   float device_scale_factor = 2.5f;
@@ -6908,7 +6910,7 @@ TEST(LayerTreeHostCommonTest,
   parent->AddChild(child);
   parent->AddChild(child_no_scale);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
 
   float device_scale_factor = 1.7f;
@@ -7059,7 +7061,7 @@ TEST(LayerTreeHostCommonTest, ContentsScale) {
   parent->AddChild(child_no_scale);
   parent->AddChild(child_no_auto_scale);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
 
   float device_scale_factor = 2.5f;
@@ -7233,7 +7235,7 @@ TEST(LayerTreeHostCommonTest, SmallContentsScale) {
 
   parent->AddChild(child_scale);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
 
   float device_scale_factor = 2.5f;
@@ -7414,7 +7416,7 @@ TEST(LayerTreeHostCommonTest, ContentsScaleForSurfaces) {
   surface_no_auto_scale->AddChild(surface_no_auto_scale_child_scale);
   surface_no_auto_scale->AddChild(surface_no_auto_scale_child_no_scale);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
 
   double device_scale_factor = 5;
@@ -7623,7 +7625,7 @@ TEST(LayerTreeHostCommonTest, ContentsScaleForAnimatingLayer) {
   int animation_id = AddAnimatedTransformToController(
       child_scale->layer_animation_controller(), 10.0, 30, 0);
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
 
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
@@ -7706,7 +7708,7 @@ TEST(LayerTreeHostCommonTest, RenderSurfaceTransformsInHighDPI) {
   child->AddChild(duplicate_child_non_owner);
   child->SetReplicaLayer(replica.get());
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
 
   float device_scale_factor = 1.5f;
@@ -7841,7 +7843,7 @@ TEST(LayerTreeHostCommonTest,
   child->AddChild(duplicate_child_non_owner);
   child->SetReplicaLayer(replica.get());
 
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list;
+  LayerList render_surface_layer_list;
   int dummy_max_texture_size = 512;
 
   float device_scale_factor = 1.7f;
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 3d975ee..281671e 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -24,7 +24,9 @@
 #include "cc/input/top_controls_manager.h"
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
+#include "cc/layers/layer_impl.h"
 #include "cc/layers/layer_iterator.h"
+#include "cc/layers/render_surface_impl.h"
 #include "cc/layers/scrollbar_layer_impl.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/delegating_renderer.h"
@@ -364,7 +366,7 @@ bool LayerTreeHostImpl::HaveTouchEventHandlersAt(gfx::Point viewport_point) {
 
 void LayerTreeHostImpl::TrackDamageForAllSurfaces(
     LayerImpl* root_draw_layer,
-    const LayerList& render_surface_layer_list) {
+    const LayerImplList& render_surface_layer_list) {
   // For now, we use damage tracking to compute a global scissor. To do this, we
   // must compute all damage tracking before drawing anything, so that we know
   // the root damage rect. The root damage rect is then used to scissor each
@@ -539,7 +541,7 @@ bool LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
   // Add quads to the Render passes in FrontToBack order to allow for testing
   // occlusion and performing culling during the tree walk.
   typedef LayerIterator<LayerImpl,
-                        std::vector<LayerImpl*>,
+                        LayerImplList,
                         RenderSurfaceImpl,
                         LayerIteratorActions::FrontToBack> LayerIteratorType;
 
@@ -2040,7 +2042,7 @@ LayerImpl* LayerTreeHostImpl::GetNonCompositedContentLayerRecursive(
   if (layer->DrawsContent())
     return layer;
 
-  for (LayerImpl::LayerList::const_iterator it = layer->children().begin();
+  for (LayerImplList::const_iterator it = layer->children().begin();
        it != layer->children().end(); ++it) {
     LayerImpl* nccr = GetNonCompositedContentLayerRecursive(*it);
     if (nccr)
diff --git a/cc/trees/layer_tree_host_impl.h b/cc/trees/layer_tree_host_impl.h
index ea31904..08ade52 100644
--- a/cc/trees/layer_tree_host_impl.h
+++ b/cc/trees/layer_tree_host_impl.h
@@ -16,6 +16,7 @@
 #include "cc/base/cc_export.h"
 #include "cc/input/input_handler.h"
 #include "cc/input/top_controls_manager_client.h"
+#include "cc/layers/layer_lists.h"
 #include "cc/layers/render_pass_sink.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/renderer.h"
@@ -83,8 +84,6 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandlerClient,
                                     public OutputSurfaceClient,
                                     public TopControlsManagerClient {
  public:
-  typedef std::vector<LayerImpl*> LayerList;
-
   static scoped_ptr<LayerTreeHostImpl> Create(
       const LayerTreeSettings& settings,
       LayerTreeHostImplClient* client,
@@ -129,8 +128,8 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandlerClient,
     std::vector<gfx::Rect> non_occluding_screen_space_rects;
     RenderPassList render_passes;
     RenderPassIdHashMap render_passes_by_id;
-    const LayerList* render_surface_layer_list;
-    LayerList will_draw_layers;
+    const LayerImplList* render_surface_layer_list;
+    LayerImplList will_draw_layers;
     bool contains_incomplete_tile;
 
     // RenderPassSink implementation.
@@ -381,8 +380,9 @@ class CC_EXPORT LayerTreeHostImpl : public InputHandlerClient,
       gfx::Vector2dF viewport_delta);
 
   void UpdateMaxScrollOffset();
-  void TrackDamageForAllSurfaces(LayerImpl* root_draw_layer,
-                                 const LayerList& render_surface_layer_list);
+  void TrackDamageForAllSurfaces(
+      LayerImpl* root_draw_layer,
+      const LayerImplList& render_surface_layer_list);
 
   // Returns false if the frame should not be displayed. This function should
   // only be called from PrepareToDraw, as DidDrawAllLayers must be called
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 737ef2a..19e33e1 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -16,6 +16,7 @@
 #include "cc/layers/io_surface_layer_impl.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/quad_sink.h"
+#include "cc/layers/render_surface_impl.h"
 #include "cc/layers/scrollbar_geometry_fixed_thumb.h"
 #include "cc/layers/scrollbar_layer_impl.h"
 #include "cc/layers/solid_color_layer_impl.h"
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index 767c00d..607492e 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -697,7 +697,7 @@ class LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers
     impl->PrepareToDraw(&frame_data);
     impl->DidDrawAllLayers(frame_data);
 
-    const LayerTreeHostImpl::LayerList& render_surface_layer_list =
+    const LayerImplList& render_surface_layer_list =
         *frame_data.render_surface_layer_list;
 
     // Both layers should be drawing into the root render surface.
diff --git a/cc/trees/layer_tree_host_unittest_video.cc b/cc/trees/layer_tree_host_unittest_video.cc
index 86d4dc4..5413a60 100644
--- a/cc/trees/layer_tree_host_unittest_video.cc
+++ b/cc/trees/layer_tree_host_unittest_video.cc
@@ -5,6 +5,7 @@
 #include "cc/trees/layer_tree_host.h"
 
 #include "base/basictypes.h"
+#include "cc/layers/render_surface_impl.h"
 #include "cc/layers/video_layer.h"
 #include "cc/layers/video_layer_impl.h"
 #include "cc/test/fake_video_frame_provider.h"
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index 004af24..bc9acf5 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -12,6 +12,7 @@
 #include "cc/input/pinch_zoom_scrollbar.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
+#include "cc/layers/render_surface_impl.h"
 #include "cc/layers/scrollbar_layer_impl.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_host_impl.h"
@@ -334,7 +335,7 @@ bool LayerTreeImpl::AreVisibleResourcesReady() const {
   TRACE_EVENT0("cc", "LayerTreeImpl::AreVisibleResourcesReady");
 
   typedef LayerIterator<LayerImpl,
-                        std::vector<LayerImpl*>,
+                        LayerImplList,
                         RenderSurfaceImpl,
                         LayerIteratorActions::BackToFront> LayerIteratorType;
   LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list_);
@@ -347,7 +348,7 @@ bool LayerTreeImpl::AreVisibleResourcesReady() const {
   return true;
 }
 
-const LayerTreeImpl::LayerList& LayerTreeImpl::RenderSurfaceLayerList() const {
+const LayerImplList& LayerTreeImpl::RenderSurfaceLayerList() const {
   // If this assert triggers, then the list is dirty.
   DCHECK(!needs_update_draw_properties_);
   return render_surface_layer_list_;
@@ -538,7 +539,7 @@ AnimationRegistrar* LayerTreeImpl::animationRegistrar() const {
 scoped_ptr<base::Value> LayerTreeImpl::AsValue() const {
   scoped_ptr<base::ListValue> state(new base::ListValue());
   typedef LayerIterator<LayerImpl,
-                        std::vector<LayerImpl*>,
+                        LayerImplList,
                         RenderSurfaceImpl,
                         LayerIteratorActions::BackToFront> LayerIteratorType;
   LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list_);
diff --git a/cc/trees/layer_tree_impl.h b/cc/trees/layer_tree_impl.h
index 1aaf3ba..04680c1 100644
--- a/cc/trees/layer_tree_impl.h
+++ b/cc/trees/layer_tree_impl.h
@@ -43,8 +43,6 @@ struct RendererCapabilities;
 
 class CC_EXPORT LayerTreeImpl {
  public:
-  typedef std::vector<LayerImpl*> LayerList;
-
   static scoped_ptr<LayerTreeImpl> create(
       LayerTreeHostImpl* layer_tree_host_impl) {
     return make_scoped_ptr(new LayerTreeImpl(layer_tree_host_impl));
@@ -161,7 +159,7 @@ class CC_EXPORT LayerTreeImpl {
 
   bool AreVisibleResourcesReady() const;
 
-  const LayerList& RenderSurfaceLayerList() const;
+  const LayerImplList& RenderSurfaceLayerList() const;
 
   // These return the size of the root scrollable area and the size of
   // the user-visible scrolling viewport, in CSS layout coordinates.
@@ -239,7 +237,7 @@ class CC_EXPORT LayerTreeImpl {
 
   // List of visible layers for the most recently prepared frame. Used for
   // rendering and input event hit testing.
-  LayerList render_surface_layer_list_;
+  LayerImplList render_surface_layer_list_;
 
   bool contents_textures_purged_;
   bool viewport_size_invalid_;
diff --git a/cc/trees/occlusion_tracker.cc b/cc/trees/occlusion_tracker.cc
index 1efb6c9..f3e5234 100644
--- a/cc/trees/occlusion_tracker.cc
+++ b/cc/trees/occlusion_tracker.cc
@@ -10,6 +10,8 @@
 #include "cc/debug/overdraw_metrics.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
+#include "cc/layers/render_surface.h"
+#include "cc/layers/render_surface_impl.h"
 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/rect_conversions.h"
 
diff --git a/cc/trees/occlusion_tracker_unittest.cc b/cc/trees/occlusion_tracker_unittest.cc
index 8d6477b..9741d63 100644
--- a/cc/trees/occlusion_tracker_unittest.cc
+++ b/cc/trees/occlusion_tracker_unittest.cc
@@ -136,7 +136,7 @@ struct OcclusionTrackerTestMainThreadTypes {
   typedef scoped_refptr<Layer> LayerPtrType;
   typedef scoped_refptr<ContentLayerType> ContentLayerPtrType;
   typedef LayerIterator<Layer,
-                        std::vector<scoped_refptr<Layer> >,
+                        LayerList,
                         RenderSurface,
                         LayerIteratorActions::FrontToBack> TestLayerIterator;
   typedef OcclusionTracker OcclusionTrackerType;
@@ -169,7 +169,7 @@ struct OcclusionTrackerTestImplThreadTypes {
   typedef scoped_ptr<LayerImpl> LayerPtrType;
   typedef scoped_ptr<ContentLayerType> ContentLayerPtrType;
   typedef LayerIterator<LayerImpl,
-                        std::vector<LayerImpl*>,
+                        LayerImplList,
                         RenderSurfaceImpl,
                         LayerIteratorActions::FrontToBack> TestLayerIterator;
   typedef OcclusionTrackerImpl OcclusionTrackerType;
@@ -449,13 +449,13 @@ template <typename Types> class OcclusionTrackerTest : public testing::Test {
   bool opaque_layers_;
   // These hold ownership of the layers for the duration of the test.
   typename Types::LayerPtrType root_;
-  std::vector<scoped_refptr<Layer> > render_surface_layer_list_;
-  std::vector<LayerImpl*> render_surface_layer_list_impl_;
+  LayerList render_surface_layer_list_;
+  LayerImplList render_surface_layer_list_impl_;
   typename Types::TestLayerIterator layer_iterator_begin_;
   typename Types::TestLayerIterator layer_iterator_;
   typename Types::LayerType* last_layer_visited_;
-  std::vector<scoped_refptr<Layer> > replica_layers_;
-  std::vector<scoped_refptr<Layer> > mask_layers_;
+  LayerList replica_layers_;
+  LayerList mask_layers_;
 };
 
 template <>
diff --git a/cc/trees/quad_culler_unittest.cc b/cc/trees/quad_culler_unittest.cc
index c2835d3..b0575f4 100644
--- a/cc/trees/quad_culler_unittest.cc
+++ b/cc/trees/quad_culler_unittest.cc
@@ -9,6 +9,7 @@
 #include "cc/base/math_util.h"
 #include "cc/debug/overdraw_metrics.h"
 #include "cc/layers/append_quads_data.h"
+#include "cc/layers/render_surface_impl.h"
 #include "cc/layers/tiled_layer_impl.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/resources/layer_tiling_data.h"
@@ -43,7 +44,7 @@ class TestOcclusionTrackerImpl : public OcclusionTrackerImpl {
 };
 
 typedef LayerIterator<LayerImpl,
-                      std::vector<LayerImpl*>,
+                      LayerImplList,
                       RenderSurfaceImpl,
                       LayerIteratorActions::FrontToBack> LayerIteratorType;
 
@@ -60,7 +61,7 @@ class QuadCullerTest : public testing::Test {
       float opacity,
       bool opaque,
       gfx::Rect layer_opaque_rect,
-      std::vector<LayerImpl*>& surface_layer_list) {
+      LayerImplList& surface_layer_list) {
     scoped_ptr<TiledLayerImpl> layer =
         TiledLayerImpl::Create(host_impl_.active_tree(), layer_id_++);
     scoped_ptr<LayerTilingData> tiler = LayerTilingData::Create(
@@ -131,7 +132,7 @@ class QuadCullerTest : public testing::Test {
 #define DECLARE_AND_INITIALIZE_TEST_QUADS()                                    \
   QuadList quad_list;                                                          \
   SharedQuadStateList shared_state_list;                                       \
-  std::vector<LayerImpl*> render_surface_layer_list;                           \
+  LayerImplList render_surface_layer_list;                                     \
   gfx::Transform child_transform;                                              \
   gfx::Size root_size = gfx::Size(300, 300);                                   \
   gfx::Rect root_rect = gfx::Rect(root_size);                                  \
diff --git a/cc/trees/tree_synchronizer.cc b/cc/trees/tree_synchronizer.cc
index 130d404..8b4d4d6 100644
--- a/cc/trees/tree_synchronizer.cc
+++ b/cc/trees/tree_synchronizer.cc
@@ -22,8 +22,8 @@ void CollectExistingLayerImplRecursive(ScopedPtrLayerImplMap* old_layers,
   if (!layer_impl)
     return;
 
-  ScopedPtrVector<LayerImpl>& children = layer_impl->children();
-  for (ScopedPtrVector<LayerImpl>::iterator it = children.begin();
+  OwnedLayerImplList& children = layer_impl->children();
+  for (OwnedLayerImplList::iterator it = children.begin();
        it != children.end();
        ++it)
     CollectExistingLayerImplRecursive(old_layers, children.take(it));
@@ -198,7 +198,7 @@ void PushPropertiesInternal(LayerType* layer, LayerImpl* layer_impl) {
   PushPropertiesInternal(layer->mask_layer(), layer_impl->mask_layer());
   PushPropertiesInternal(layer->replica_layer(), layer_impl->replica_layer());
 
-  const ScopedPtrVector<LayerImpl>& impl_children = layer_impl->children();
+  const OwnedLayerImplList& impl_children = layer_impl->children();
   DCHECK_EQ(layer->children().size(), impl_children.size());
 
   for (size_t i = 0; i < layer->children().size(); ++i) {
diff --git a/cc/trees/tree_synchronizer_unittest.cc b/cc/trees/tree_synchronizer_unittest.cc
index c402afc..5c9bc92 100644
--- a/cc/trees/tree_synchronizer_unittest.cc
+++ b/cc/trees/tree_synchronizer_unittest.cc
@@ -119,9 +119,8 @@ void ExpectTreesAreIdentical(Layer* layer,
         layer->replica_layer(), layer_impl->replica_layer(), tree_impl);
   }
 
-  const std::vector<scoped_refptr<Layer> >& layer_children = layer->children();
-  const ScopedPtrVector<LayerImpl>& layer_impl_children =
-      layer_impl->children();
+  const LayerList& layer_children = layer->children();
+  const OwnedLayerImplList& layer_impl_children = layer_impl->children();
 
   ASSERT_EQ(layer_children.size(), layer_impl_children.size());