Use custom ListContainer to allocate DrawQuads

cc/trees/layer_tree_host_impl_unittest.cc

 // Copyright 2011 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_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 3875 matching lines @@
   void set_gutter_quad_material(DrawQuad::Material material) {
     gutter_quad_material_ = material;
   }
   void set_gutter_texture_size(const gfx::Size& gutter_texture_size) {
     gutter_texture_size_ = gutter_texture_size;
   }
 
  protected:
   size_t CountGutterQuads(const QuadList& quad_list) {
     size_t num_gutter_quads = 0;
-    for (size_t i = 0; i < quad_list.size(); ++i) {
-      num_gutter_quads += (quad_list[i]->material ==
-                           gutter_quad_material_) ? 1 : 0;
+    for (QuadList::ConstIterator iter = quad_list.begin();
+         iter != quad_list.end();
+         ++iter) {
+      num_gutter_quads += (iter->material == gutter_quad_material_) ? 1 : 0;
     }
     return num_gutter_quads;
   }
 
   void VerifyQuadsExactlyCoverViewport(const QuadList& quad_list) {
     LayerTestCommon::VerifyQuadsExactlyCoverRect(
         quad_list, gfx::Rect(DipSizeToPixelSize(viewport_size_)));
   }
 
   // Make sure that the texture coordinates match their expectations.
   void ValidateTextureDrawQuads(const QuadList& quad_list) {
-    for (size_t i = 0; i < quad_list.size(); ++i) {
-      if (quad_list[i]->material != DrawQuad::TEXTURE_CONTENT)
+    for (QuadList::ConstIterator iter = quad_list.begin();
+         iter != quad_list.end();
+         ++iter) {
+      if (iter->material != DrawQuad::TEXTURE_CONTENT)
         continue;
-      const TextureDrawQuad* quad = TextureDrawQuad::MaterialCast(quad_list[i]);
+      const TextureDrawQuad* quad = TextureDrawQuad::MaterialCast(&*iter);
       gfx::SizeF gutter_texture_size_pixels = gfx::ScaleSize(
           gutter_texture_size_, host_impl_->device_scale_factor());
       EXPECT_EQ(quad->uv_top_left.x(),
                 quad->rect.x() / gutter_texture_size_pixels.width());
       EXPECT_EQ(quad->uv_top_left.y(),
                 quad->rect.y() / gutter_texture_size_pixels.height());
       EXPECT_EQ(quad->uv_bottom_right.x(),
                 quad->rect.right() / gutter_texture_size_pixels.width());
       EXPECT_EQ(quad->uv_bottom_right.y(),
                 quad->rect.bottom() / gutter_texture_size_pixels.height());
@@ skipping 578 matching lines @@
                             &stats_instrumentation_);
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, my_host_impl->PrepareToDraw(&frame));
 
     // Verify all quads have been computed
     ASSERT_EQ(2U, frame.render_passes.size());
     ASSERT_EQ(1U, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(1U, frame.render_passes[1]->quad_list.size());
     EXPECT_EQ(DrawQuad::SOLID_COLOR,
-              frame.render_passes[0]->quad_list[0]->material);
+              frame.render_passes[0]->quad_list.front()->material);
     EXPECT_EQ(DrawQuad::RENDER_PASS,
-              frame.render_passes[1]->quad_list[0]->material);
+              frame.render_passes[1]->quad_list.front()->material);
 
     my_host_impl->DrawLayers(&frame, gfx::FrameTime::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 }
 
 TEST_F(LayerTreeHostImplTest, ContributingLayerEmptyScissorNoPartialSwap) {
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
   scoped_ptr<LayerTreeHostImpl> my_host_impl =
       SetupLayersForOpacity(false,
                             this,
                             &proxy_,
                             shared_bitmap_manager.get(),
                             &stats_instrumentation_);
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, my_host_impl->PrepareToDraw(&frame));
 
     // Verify all quads have been computed
     ASSERT_EQ(2U, frame.render_passes.size());
     ASSERT_EQ(1U, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(1U, frame.render_passes[1]->quad_list.size());
     EXPECT_EQ(DrawQuad::SOLID_COLOR,
-              frame.render_passes[0]->quad_list[0]->material);
+              frame.render_passes[0]->quad_list.front()->material);
     EXPECT_EQ(DrawQuad::RENDER_PASS,
-              frame.render_passes[1]->quad_list[0]->material);
+              frame.render_passes[1]->quad_list.front()->material);
 
     my_host_impl->DrawLayers(&frame, gfx::FrameTime::Now());
     my_host_impl->DidDrawAllLayers(frame);
   }
 }
 
 TEST_F(LayerTreeHostImplTest, LayersFreeTextures) {
   scoped_ptr<TestWebGraphicsContext3D> context =
       TestWebGraphicsContext3D::Create();
   TestWebGraphicsContext3D* context3d = context.get();
@@ skipping 152 matching lines @@
       const RenderPass* root_render_pass = frame.render_passes.back();
       EXPECT_RECT_EQ(expected_damage, root_render_pass->damage_rect);
 
       // Verify the root and child layers' quads are generated and not being
       // culled.
       ASSERT_EQ(2u, root_render_pass->quad_list.size());
 
       LayerImpl* child = host_impl_->active_tree()->root_layer()->children()[0];
       gfx::RectF expected_child_visible_rect(child->content_bounds());
       EXPECT_RECT_EQ(expected_child_visible_rect,
-                     root_render_pass->quad_list[0]->visible_rect);
+                     root_render_pass->quad_list.front()->visible_rect);
 
       LayerImpl* root = host_impl_->active_tree()->root_layer();
       gfx::RectF expected_root_visible_rect(root->content_bounds());
-      EXPECT_RECT_EQ(expected_root_visible_rect,
-                     root_render_pass->quad_list[1]->visible_rect);
+      QuadList::ConstIterator iter = root_render_pass->quad_list.begin();
+      ++iter;
+      EXPECT_RECT_EQ(expected_root_visible_rect, iter->visible_rect);
     }
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
     EXPECT_EQ(expect_to_draw, host_impl_->SwapBuffers(frame));
   }
 };
 
 TEST_F(LayerTreeHostImplTestWithDelegatingRenderer, FrameIncludesDamageRect) {
   scoped_ptr<SolidColorLayerImpl> root =
@@ skipping 113 matching lines @@
   float device_scale_factor = 1.f;
   host_impl_->SetViewportSize(root_size);
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(DrawQuad::RENDER_PASS,
-              frame.render_passes[0]->quad_list[0]->material);
+              frame.render_passes[0]->quad_list.front()->material);
     const RenderPassDrawQuad* render_pass_quad =
-        RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
+        RenderPassDrawQuad::MaterialCast(
+            frame.render_passes[0]->quad_list.front());
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               render_pass_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 
 
   // Applying a DSF should change the render surface size, but won't affect
   // which part of the mask is used.
   device_scale_factor = 2.f;
   gfx::Size device_viewport =
       gfx::ToFlooredSize(gfx::ScaleSize(root_size, device_scale_factor));
   host_impl_->SetViewportSize(device_viewport);
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(DrawQuad::RENDER_PASS,
-              frame.render_passes[0]->quad_list[0]->material);
+              frame.render_passes[0]->quad_list.front()->material);
     const RenderPassDrawQuad* render_pass_quad =
-        RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
+        RenderPassDrawQuad::MaterialCast(
+            frame.render_passes[0]->quad_list.front());
     EXPECT_EQ(gfx::Rect(0, 0, 200, 200).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               render_pass_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 
 
   // Applying an equivalent content scale on the content layer and the mask
   // should still result in the same part of the mask being used.
   gfx::Size content_bounds =
       gfx::ToRoundedSize(gfx::ScaleSize(scaling_layer_size,
                                         device_scale_factor));
   content_layer->SetContentBounds(content_bounds);
   content_layer->SetContentsScale(device_scale_factor, device_scale_factor);
   mask_layer->SetContentBounds(content_bounds);
   mask_layer->SetContentsScale(device_scale_factor, device_scale_factor);
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(DrawQuad::RENDER_PASS,
-              frame.render_passes[0]->quad_list[0]->material);
+              frame.render_passes[0]->quad_list.front()->material);
     const RenderPassDrawQuad* render_pass_quad =
-        RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
+        RenderPassDrawQuad::MaterialCast(
+            frame.render_passes[0]->quad_list.front());
     EXPECT_EQ(gfx::Rect(0, 0, 200, 200).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               render_pass_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 }
 
@@ skipping 37 matching lines @@
   float device_scale_factor = 1.f;
   host_impl_->SetViewportSize(root_size);
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(DrawQuad::RENDER_PASS,
-              frame.render_passes[0]->quad_list[0]->material);
+              frame.render_passes[0]->quad_list.front()->material);
     const RenderPassDrawQuad* render_pass_quad =
-        RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
+        RenderPassDrawQuad::MaterialCast(
+            frame.render_passes[0]->quad_list.front());
     EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               render_pass_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 
   // Applying a DSF should change the render surface size, but won't affect
   // which part of the mask is used.
   device_scale_factor = 2.f;
   gfx::Size device_viewport =
       gfx::ToFlooredSize(gfx::ScaleSize(root_size, device_scale_factor));
   host_impl_->SetViewportSize(device_viewport);
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(DrawQuad::RENDER_PASS,
-              frame.render_passes[0]->quad_list[0]->material);
+              frame.render_passes[0]->quad_list.front()->material);
     const RenderPassDrawQuad* render_pass_quad =
-        RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
+        RenderPassDrawQuad::MaterialCast(
+            frame.render_passes[0]->quad_list.front());
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               render_pass_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 
   // Applying an equivalent content scale on the content layer and the mask
   // should still result in the same part of the mask being used.
   gfx::Size layer_size_large =
       gfx::ToRoundedSize(gfx::ScaleSize(layer_size, device_scale_factor));
   content_layer->SetContentBounds(layer_size_large);
   content_layer->SetContentsScale(device_scale_factor, device_scale_factor);
   gfx::Size mask_size_large =
       gfx::ToRoundedSize(gfx::ScaleSize(mask_size, device_scale_factor));
   mask_layer->SetContentBounds(mask_size_large);
   mask_layer->SetContentsScale(device_scale_factor, device_scale_factor);
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(DrawQuad::RENDER_PASS,
-              frame.render_passes[0]->quad_list[0]->material);
+              frame.render_passes[0]->quad_list.front()->material);
     const RenderPassDrawQuad* render_pass_quad =
-        RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
+        RenderPassDrawQuad::MaterialCast(
+            frame.render_passes[0]->quad_list.front());
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               render_pass_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 
   // Applying a different contents scale to the mask layer means it will have
   // a larger texture, but it should use the same tex coords to cover the
   // layer it masks.
   mask_layer->SetContentBounds(mask_size);
   mask_layer->SetContentsScale(1.f, 1.f);
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ASSERT_EQ(DrawQuad::RENDER_PASS,
-              frame.render_passes[0]->quad_list[0]->material);
+              frame.render_passes[0]->quad_list.front()->material);
     const RenderPassDrawQuad* render_pass_quad =
-        RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
+        RenderPassDrawQuad::MaterialCast(
+            frame.render_passes[0]->quad_list.front());
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               render_pass_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               render_pass_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 }
 
@@ skipping 41 matching lines @@
   // Check that the mask fills the surface.
   float device_scale_factor = 1.f;
   host_impl_->SetViewportSize(root_size);
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(2u, frame.render_passes[0]->quad_list.size());
-    ASSERT_EQ(DrawQuad::RENDER_PASS,
-              frame.render_passes[0]->quad_list[1]->material);
+    QuadList::ConstIterator iter = frame.render_passes[0]->quad_list.begin();
+    ++iter;
+    ASSERT_EQ(DrawQuad::RENDER_PASS, iter->material);
     const RenderPassDrawQuad* replica_quad =
-        RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[1]);
+        RenderPassDrawQuad::MaterialCast(&*iter);
     EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(),
               replica_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               replica_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 
   // Applying a DSF should change the render surface size, but won't affect
   // which part of the mask is used.
   device_scale_factor = 2.f;
   gfx::Size device_viewport =
       gfx::ToFlooredSize(gfx::ScaleSize(root_size, device_scale_factor));
   host_impl_->SetViewportSize(device_viewport);
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(2u, frame.render_passes[0]->quad_list.size());
-    ASSERT_EQ(DrawQuad::RENDER_PASS,
-              frame.render_passes[0]->quad_list[1]->material);
+    QuadList::ConstIterator iter = frame.render_passes[0]->quad_list.begin();
+    ++iter;
+    ASSERT_EQ(DrawQuad::RENDER_PASS, iter->material);
     const RenderPassDrawQuad* replica_quad =
-        RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[1]);
+        RenderPassDrawQuad::MaterialCast(&*iter);
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               replica_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               replica_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 
   // Applying an equivalent content scale on the content layer and the mask
   // should still result in the same part of the mask being used.
   gfx::Size layer_size_large =
       gfx::ToRoundedSize(gfx::ScaleSize(layer_size, device_scale_factor));
   content_layer->SetContentBounds(layer_size_large);
   content_layer->SetContentsScale(device_scale_factor, device_scale_factor);
   gfx::Size mask_size_large =
       gfx::ToRoundedSize(gfx::ScaleSize(mask_size, device_scale_factor));
   mask_layer->SetContentBounds(mask_size_large);
   mask_layer->SetContentsScale(device_scale_factor, device_scale_factor);
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(2u, frame.render_passes[0]->quad_list.size());
-    ASSERT_EQ(DrawQuad::RENDER_PASS,
-              frame.render_passes[0]->quad_list[1]->material);
+    QuadList::ConstIterator iter = frame.render_passes[0]->quad_list.begin();
+    ++iter;
+    ASSERT_EQ(DrawQuad::RENDER_PASS, iter->material);
     const RenderPassDrawQuad* replica_quad =
-        RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[1]);
+        RenderPassDrawQuad::MaterialCast(&*iter);
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               replica_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               replica_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 
   // Applying a different contents scale to the mask layer means it will have
   // a larger texture, but it should use the same tex coords to cover the
   // layer it masks.
   mask_layer->SetContentBounds(mask_size);
   mask_layer->SetContentsScale(1.f, 1.f);
   host_impl_->active_tree()->set_needs_update_draw_properties();
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(2u, frame.render_passes[0]->quad_list.size());
-    ASSERT_EQ(DrawQuad::RENDER_PASS,
-              frame.render_passes[0]->quad_list[1]->material);
+    QuadList::ConstIterator iter = frame.render_passes[0]->quad_list.begin();
+    ++iter;
+    ASSERT_EQ(DrawQuad::RENDER_PASS, iter->material);
     const RenderPassDrawQuad* replica_quad =
-        RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[1]);
+        RenderPassDrawQuad::MaterialCast(&*iter);
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               replica_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
               replica_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 }
 
@@ skipping 54 matching lines @@
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(2u, frame.render_passes[0]->quad_list.size());
 
     // The surface is 100x50.
     ASSERT_EQ(DrawQuad::RENDER_PASS,
-              frame.render_passes[0]->quad_list[0]->material);
+              frame.render_passes[0]->quad_list.front()->material);
     const RenderPassDrawQuad* render_pass_quad =
-        RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
+        RenderPassDrawQuad::MaterialCast(
+            frame.render_passes[0]->quad_list.front());
     EXPECT_EQ(gfx::Rect(0, 0, 100, 50).ToString(),
               render_pass_quad->rect.ToString());
 
     // The mask covers the owning layer only.
-    ASSERT_EQ(DrawQuad::RENDER_PASS,
-              frame.render_passes[0]->quad_list[1]->material);
+    QuadList::ConstIterator iter = frame.render_passes[0]->quad_list.begin();
+    ++iter;
+    ASSERT_EQ(DrawQuad::RENDER_PASS, iter->material);
     const RenderPassDrawQuad* replica_quad =
-        RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[1]);
+        RenderPassDrawQuad::MaterialCast(&*iter);
     EXPECT_EQ(gfx::Rect(0, 0, 100, 50).ToString(),
               replica_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(0.f, 0.f, 2.f, 1.f).ToString(),
               replica_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 
   // Move the child to (-50, 0) instead. Now the mask should be moved to still
   // cover the layer being replicated.
   content_child_layer->SetPosition(gfx::Point(-50, 0));
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(2u, frame.render_passes[0]->quad_list.size());
 
     // The surface is 100x50 with its origin at (-50, 0).
     ASSERT_EQ(DrawQuad::RENDER_PASS,
-              frame.render_passes[0]->quad_list[0]->material);
+              frame.render_passes[0]->quad_list.front()->material);
     const RenderPassDrawQuad* render_pass_quad =
-        RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
+        RenderPassDrawQuad::MaterialCast(
+            frame.render_passes[0]->quad_list.front());
     EXPECT_EQ(gfx::Rect(-50, 0, 100, 50).ToString(),
               render_pass_quad->rect.ToString());
 
     // The mask covers the owning layer only.
-    ASSERT_EQ(DrawQuad::RENDER_PASS,
-              frame.render_passes[0]->quad_list[1]->material);
+    QuadList::ConstIterator iter = frame.render_passes[0]->quad_list.begin();
+    ++iter;
+    ASSERT_EQ(DrawQuad::RENDER_PASS, iter->material);
     const RenderPassDrawQuad* replica_quad =
-        RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[1]);
+        RenderPassDrawQuad::MaterialCast(&*iter);
     EXPECT_EQ(gfx::Rect(-50, 0, 100, 50).ToString(),
               replica_quad->rect.ToString());
     EXPECT_EQ(gfx::RectF(-1.f, 0.f, 2.f, 1.f).ToString(),
               replica_quad->mask_uv_rect.ToString());
 
     host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
     host_impl_->DidDrawAllLayers(frame);
   }
 }
 
@@ skipping 61 matching lines @@
   host_impl_->SetDeviceScaleFactor(device_scale_factor);
   {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
     ASSERT_EQ(1u, frame.render_passes.size());
     ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
 
     // The surface is clipped to 10x20.
     ASSERT_EQ(DrawQuad::RENDER_PASS,
-              frame.render_passes[0]->quad_list[0]->material);
+              frame.render_passes[0]->quad_list.front()->material);
     const RenderPassDrawQuad* render_pass_quad =
-        RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
+        RenderPassDrawQuad::MaterialCast(
+            frame.render_passes[0]->quad_list.front());
     EXPECT_EQ(gfx::Rect(20, 10, 10, 20).ToString(),
               render_pass_quad->rect.ToString());
 
     // The masked layer is 50x50, but the surface size is 10x20. So the texture
     // coords in the mask are scaled by 10/50 and 20/50.
     // The surface is clipped to (20,10) so the mask texture coords are offset
     // by 20/50 and 10/50
     EXPECT_EQ(gfx::ScaleRect(gfx::RectF(20.f, 10.f, 10.f, 20.f),
                              1.f / 50.f).ToString(),
               render_pass_quad->mask_uv_rect.ToString());
@@ skipping 54 matching lines @@
   host_impl_->ActivateSyncTree();
 
   host_impl_->active_tree()->UpdateDrawProperties();
   ASSERT_EQ(1u, host_impl_->active_tree()->RenderSurfaceLayerList().size());
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   ASSERT_EQ(1u, frame.render_passes.size());
   ASSERT_LE(1u, frame.render_passes[0]->quad_list.size());
-  const DrawQuad* quad = frame.render_passes[0]->quad_list[0];
+  const DrawQuad* quad = frame.render_passes[0]->quad_list.front();
 
   float edge[24];
   gfx::QuadF device_layer_quad;
   bool antialiased =
       GLRendererWithSetupQuadForAntialiasing::SetupQuadForAntialiasing(
           quad->quadTransform(), quad, &device_layer_quad, edge);
   EXPECT_FALSE(antialiased);
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
@@ skipping 1490 matching lines @@
   // surface.
   EXPECT_EQ(0, num_lost_surfaces_);
   host_impl_->DidLoseOutputSurface();
   EXPECT_EQ(1, num_lost_surfaces_);
   host_impl_->DidLoseOutputSurface();
   EXPECT_LE(1, num_lost_surfaces_);
 }
 
 }  // namespace
 }  // namespace cc