cc: Consolidate LayerList types.

cc/trees/occlusion_tracker_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/occlusion_tracker.h"
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/overdraw_metrics.h"
 #include "cc/layers/layer.h"
@@ skipping 118 matching lines @@
 };
 
 struct OcclusionTrackerTestMainThreadTypes {
   typedef Layer LayerType;
   typedef LayerTreeHost HostType;
   typedef RenderSurface RenderSurfaceType;
   typedef TestContentLayer ContentLayerType;
   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;
 
   static LayerPtrType CreateLayer(HostType*  host) { return Layer::Create(); }
   static ContentLayerPtrType CreateContentLayer(HostType* host) {
     return make_scoped_refptr(new ContentLayerType());
   }
 
   static LayerPtrType PassLayerPtr(ContentLayerPtrType* layer) {
@@ skipping 12 matching lines @@
 };
 
 struct OcclusionTrackerTestImplThreadTypes {
   typedef LayerImpl LayerType;
   typedef LayerTreeImpl HostType;
   typedef RenderSurfaceImpl RenderSurfaceType;
   typedef TestContentLayerImpl ContentLayerType;
   typedef scoped_ptr<LayerImpl> LayerPtrType;
   typedef scoped_ptr<ContentLayerType> ContentLayerPtrType;
   typedef LayerIterator<LayerImpl,
-                        std::vector<LayerImpl*>,
+                        LayerImplList,
                         RenderSurfaceImpl,
                         LayerIteratorActions::FrontToBack> TestLayerIterator;
   typedef OcclusionTrackerImpl OcclusionTrackerType;
 
   static LayerPtrType CreateLayer(HostType* host) {
     return LayerImpl::Create(host, next_layer_impl_id++);
   }
   static ContentLayerPtrType CreateContentLayer(HostType* host) {
     return make_scoped_ptr(new ContentLayerType(host, next_layer_impl_id++));
   }
@@ skipping 259 matching lines @@
 
   void SetMask(LayerImpl* owning_layer, scoped_ptr<LayerImpl> layer) {
     owning_layer->SetMaskLayer(layer.Pass());
   }
 
   FakeImplProxy proxy_;
   FakeLayerTreeHostImpl host_impl_;
   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 <>
 LayerTreeHost*
 OcclusionTrackerTest<OcclusionTrackerTestMainThreadTypes>::GetHost() {
   return NULL;
 }
 
 template <>
 LayerTreeImpl*
@@ skipping 4066 matching lines @@
                        gfx::Rect(0, 0, 100, 100),
                        &has_occlusion_from_outside_target_surface));
     EXPECT_FALSE(has_occlusion_from_outside_target_surface);
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestLayerClipIsExternalOcclusion)
 
 }  // namespace
 }  // namespace cc