Use custom ListContainer to allocate DrawQuads

cc/trees/layer_tree_host_unittest_delegated.cc

 // 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.
 
 #include "cc/trees/layer_tree_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 750 matching lines @@
     EXPECT_EQ(1u, map.count(999));
     EXPECT_EQ(1u, map.count(555));
 
     ResourceProvider::ResourceId parent_resource_id1 = map.find(999)->second;
     EXPECT_NE(parent_resource_id1, 999u);
     ResourceProvider::ResourceId parent_resource_id2 = map.find(555)->second;
     EXPECT_NE(parent_resource_id2, 555u);
 
     // The resources in the quads should be remapped to the parent's namespace.
     const TextureDrawQuad* quad1 = TextureDrawQuad::MaterialCast(
-        delegated_impl->RenderPassesInDrawOrder()[0]->quad_list[0]);
+        delegated_impl->RenderPassesInDrawOrder()[0]->quad_list.ElementAt(0));
     EXPECT_EQ(parent_resource_id1, quad1->resource_id);
     const TextureDrawQuad* quad2 = TextureDrawQuad::MaterialCast(
-        delegated_impl->RenderPassesInDrawOrder()[0]->quad_list[1]);
+        delegated_impl->RenderPassesInDrawOrder()[0]->quad_list.ElementAt(1));
     EXPECT_EQ(parent_resource_id2, quad2->resource_id);
 
     EndTest();
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestRemapResourcesInQuads);
 
 class LayerTreeHostDelegatedTestReturnUnusedResources
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
@@ skipping 228 matching lines @@
     // one with resource 999) on the impl tree. And only 999 will be present
     // in the parent's resource provider.
     EXPECT_EQ(1u, map.size());
     EXPECT_EQ(1u, map.count(999));
 
     EXPECT_EQ(1u, delegated_impl->Resources().size());
     EXPECT_EQ(1u, delegated_impl->Resources().count(999));
 
     const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
     EXPECT_EQ(1u, pass->quad_list.size());
-    const TextureDrawQuad* quad = TextureDrawQuad::MaterialCast(
-        pass->quad_list[0]);
+    const TextureDrawQuad* quad =
+        TextureDrawQuad::MaterialCast(pass->quad_list.front());
     EXPECT_EQ(map.find(999)->second, quad->resource_id);
 
     EndTest();
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
                                    bool result) OVERRIDE {
     ReturnUnusedResourcesFromParent(host_impl);
   }
 };
@@ skipping 93 matching lines @@
     EXPECT_EQ(1u, map.count(555));
     EXPECT_EQ(1u, map.count(444));
 
     EXPECT_EQ(3u, delegated_impl->Resources().size());
     EXPECT_EQ(1u, delegated_impl->Resources().count(999));
     EXPECT_EQ(1u, delegated_impl->Resources().count(555));
     EXPECT_EQ(1u, delegated_impl->Resources().count(444));
 
     const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
     EXPECT_EQ(3u, pass->quad_list.size());
-    const TextureDrawQuad* quad1 = TextureDrawQuad::MaterialCast(
-        pass->quad_list[0]);
+    const TextureDrawQuad* quad1 =
+        TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(0));
     EXPECT_EQ(map.find(999)->second, quad1->resource_id);
-    const TextureDrawQuad* quad2 = TextureDrawQuad::MaterialCast(
-        pass->quad_list[1]);
+    const TextureDrawQuad* quad2 =
+        TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(1));
     EXPECT_EQ(map.find(555)->second, quad2->resource_id);
-    const TextureDrawQuad* quad3 = TextureDrawQuad::MaterialCast(
-        pass->quad_list[2]);
+    const TextureDrawQuad* quad3 =
+        TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(2));
     EXPECT_EQ(map.find(444)->second, quad3->resource_id);
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
                                    bool result) OVERRIDE {
     ReturnUnusedResourcesFromParent(host_impl);
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
@@ skipping 95 matching lines @@
         EXPECT_EQ(2u, map.size());
         EXPECT_EQ(1u, map.count(999));
         EXPECT_EQ(1u, map.count(555));
 
         EXPECT_EQ(2u, delegated_impl->Resources().size());
         EXPECT_EQ(1u, delegated_impl->Resources().count(999));
         EXPECT_EQ(1u, delegated_impl->Resources().count(555));
 
         const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
         EXPECT_EQ(2u, pass->quad_list.size());
-        const TextureDrawQuad* quad1 = TextureDrawQuad::MaterialCast(
-            pass->quad_list[0]);
+        const TextureDrawQuad* quad1 =
+            TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(0));
         EXPECT_EQ(map.find(999)->second, quad1->resource_id);
-        const TextureDrawQuad* quad2 = TextureDrawQuad::MaterialCast(
-            pass->quad_list[1]);
+        const TextureDrawQuad* quad2 =
+            TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(1));
         EXPECT_EQ(map.find(555)->second, quad2->resource_id);
         break;
       }
       case 2: {
         // We only keep resources from the last valid frame.
         EXPECT_EQ(2u, map.size());
         EXPECT_EQ(1u, map.count(999));
         EXPECT_EQ(1u, map.count(555));
 
         EXPECT_EQ(2u, delegated_impl->Resources().size());
         EXPECT_EQ(1u, delegated_impl->Resources().count(999));
         EXPECT_EQ(1u, delegated_impl->Resources().count(555));
 
         // The bad frame is dropped though, we still have the frame with 999 and
         // 555 in it.
         const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
         EXPECT_EQ(2u, pass->quad_list.size());
-        const TextureDrawQuad* quad1 = TextureDrawQuad::MaterialCast(
-            pass->quad_list[0]);
+        const TextureDrawQuad* quad1 =
+            TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(0));
         EXPECT_EQ(map.find(999)->second, quad1->resource_id);
-        const TextureDrawQuad* quad2 = TextureDrawQuad::MaterialCast(
-            pass->quad_list[1]);
+        const TextureDrawQuad* quad2 =
+            TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(1));
         EXPECT_EQ(map.find(555)->second, quad2->resource_id);
         break;
       }
       case 3: {
         // We have the new good frame with just 999 in it.
         EXPECT_EQ(1u, map.size());
         EXPECT_EQ(1u, map.count(999));
 
         EXPECT_EQ(1u, delegated_impl->Resources().size());
         EXPECT_EQ(1u, delegated_impl->Resources().count(999));
 
         const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
         EXPECT_EQ(1u, pass->quad_list.size());
-        const TextureDrawQuad* quad1 = TextureDrawQuad::MaterialCast(
-            pass->quad_list[0]);
+        const TextureDrawQuad* quad1 =
+            TextureDrawQuad::MaterialCast(pass->quad_list.front());
         EXPECT_EQ(map.find(999)->second, quad1->resource_id);
         break;
       }
     }
   }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestBadFrame);
 
 class LayerTreeHostDelegatedTestUnnamedResource
@@ skipping 879 matching lines @@
   }
 
   scoped_refptr<DelegatedRendererLayer> delegated_thief_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostDelegatedTestRemoveAndChangeResources);
 
 }  // namespace
 }  // namespace cc