cc: Consolidate LayerList types.

cc/layers/layer_iterator_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/layers/layer_iterator.h"
 
 #include <vector>
 
 #include "cc/layers/layer.h"
 #include "cc/trees/layer_tree_host_common.h"
@@ skipping 32 matching lines @@
 
   bool draws_content_;
 };
 
 #define EXPECT_COUNT(layer, target, contrib, itself)                           \
   EXPECT_EQ(target, layer->count_representing_target_surface_);                \
   EXPECT_EQ(contrib, layer->count_representing_contributing_surface_);         \
   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) {
     TestLayer* render_surface_layer = static_cast<TestLayer*>(
         (*render_surface_layerList)[surface_index].get());
     RenderSurface* render_surface = render_surface_layer->render_surface();
 
     render_surface_layer->count_representing_target_surface_ = -1;
     render_surface_layer->count_representing_contributing_surface_ = -1;
     render_surface_layer->count_representing_itself_ = -1;
 
     for (unsigned layer_index = 0;
          layer_index < render_surface->layer_list().size();
          ++layer_index) {
       TestLayer* layer = static_cast<TestLayer*>(
           render_surface->layer_list()[layer_index].get());
 
       layer->count_representing_target_surface_ = -1;
       layer->count_representing_contributing_surface_ = -1;
       layer->count_representing_itself_ = -1;
     }
   }
 }
 
 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);
        it != FrontToBack::End(render_surface_layerList);
        ++it, ++count) {
     TestLayer* layer = static_cast<TestLayer*>(*it);
     if (it.represents_target_render_surface())
       layer->count_representing_target_surface_ = count;
     if (it.represents_contributing_render_surface())
       layer->count_representing_contributing_surface_ = count;
     if (it.represents_itself())
       layer->count_representing_itself_ = count;
   }
 }
 
 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);
        it != BackToFront::End(render_surface_layerList);
        ++it, ++count) {
     TestLayer* layer = static_cast<TestLayer*>(*it);
     if (it.represents_target_render_surface())
       layer->count_representing_target_surface_ = count;
     if (it.represents_contributing_render_surface())
       layer->count_representing_contributing_surface_ = count;
     if (it.represents_itself())
       layer->count_representing_itself_ = count;
   }
 }
 
 TEST(LayerIteratorTest, EmptyTree) {
-  std::vector<scoped_refptr<Layer> > render_surface_layerList;
+  LayerList render_surface_layerList;
 
   IterateBackToFront(&render_surface_layerList);
   IterateFrontToBack(&render_surface_layerList);
 }
 
 TEST(LayerIteratorTest, SimpleTree) {
   scoped_refptr<TestLayer> root_layer = TestLayer::Create();
   scoped_refptr<TestLayer> first = TestLayer::Create();
   scoped_refptr<TestLayer> second = TestLayer::Create();
   scoped_refptr<TestLayer> third = TestLayer::Create();
   scoped_refptr<TestLayer> fourth = TestLayer::Create();
 
   root_layer->CreateRenderSurface();
 
   root_layer->AddChild(first);
   root_layer->AddChild(second);
   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,
                                                1,
                                                256,
                                                false,
                                                &render_surface_layerList);
 
   IterateBackToFront(&render_surface_layerList);
   EXPECT_COUNT(root_layer, 0, -1, 1);
@@ skipping 25 matching lines @@
 
   root_layer->AddChild(root1);
   root_layer->AddChild(root2);
   root_layer->AddChild(root3);
   root2->AddChild(root21);
   root2->AddChild(root22);
   root2->AddChild(root23);
   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,
                                                1,
                                                256,
                                                false,
                                                &render_surface_layerList);
 
   IterateBackToFront(&render_surface_layerList);
   EXPECT_COUNT(root_layer, 0, -1, 1);
@@ skipping 40 matching lines @@
   root2->SetOpacity(0.5f);
   root2->SetForceRenderSurface(true);  // Force the layer to own a new surface.
   root2->AddChild(root21);
   root2->AddChild(root22);
   root2->AddChild(root23);
   root22->SetOpacity(0.5f);
   root22->AddChild(root221);
   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,
                                                1,
                                                256,
                                                false,
                                                &render_surface_layerList);
 
   IterateBackToFront(&render_surface_layerList);
   EXPECT_COUNT(root_layer, 0, -1, 1);
@@ skipping 13 matching lines @@
   EXPECT_COUNT(root21, -1, -1, 9);
   EXPECT_COUNT(root22, 7, 8, 6);
   EXPECT_COUNT(root221, -1, -1, 5);
   EXPECT_COUNT(root23, 3, 4, 2);
   EXPECT_COUNT(root231, -1, -1, 1);
   EXPECT_COUNT(root3, -1, -1, 0);
 }
 
 }  // namespace
 }  // namespace cc