cc: Remove ScopedPtrVector and cc::remove_if.

cc/surfaces/surface_aggregator_unittest.cc

 // Copyright 2014 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/output/compositor_frame.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
@@ skipping 121 matching lines @@
     ASSERT_TRUE(aggregated_frame->delegated_frame_data);
 
     DelegatedFrameData* frame_data =
         aggregated_frame->delegated_frame_data.get();
 
     TestPassesMatchExpectations(
         expected_passes, expected_pass_count, &frame_data->render_pass_list);
 
     // Ensure no duplicate pass ids output.
     std::set<RenderPassId> used_passes;
-    for (auto* pass : frame_data->render_pass_list) {
+    for (const scoped_ptr<RenderPass>& pass : frame_data->render_pass_list) {

[danakj, 2015/11/17 01:12:17]

auto

       EXPECT_TRUE(used_passes.insert(pass->id).second);
     }
 
     EXPECT_EQ(expected_surface_count,
               aggregator_.previous_contained_surfaces().size());
     for (size_t i = 0; i < expected_surface_count; i++) {
       EXPECT_TRUE(
           aggregator_.previous_contained_surfaces().find(surface_ids[i]) !=
           aggregator_.previous_contained_surfaces().end());
     }
@@ skipping 382 matching lines @@
   for (size_t i = 0; i < 5; ++i) {
     for (size_t j = 0; j < i; ++j) {
       EXPECT_NE(actual_pass_ids[i], actual_pass_ids[j]);
     }
   }
 
   {
     SCOPED_TRACE("First pass");
     // The first pass will just be the first pass from the root surfaces quad
     // with no render pass quads to remap.
-    TestPassMatchesExpectations(root_passes[0], aggregated_pass_list[0]);
+    TestPassMatchesExpectations(root_passes[0], aggregated_pass_list[0].get());
   }
 
   {
     SCOPED_TRACE("Second pass");
     // The next two passes will be from the embedded surface since we have to
     // draw those passes before they are referenced from the render pass draw
     // quad embedded into the root surface's second pass.
     // First, there's the first embedded pass which doesn't reference anything
     // else.
-    TestPassMatchesExpectations(embedded_passes[0], aggregated_pass_list[1]);
+    TestPassMatchesExpectations(embedded_passes[0],
+                                aggregated_pass_list[1].get());
   }
 
   {
     SCOPED_TRACE("Third pass");
     const QuadList& third_pass_quad_list = aggregated_pass_list[2]->quad_list;
     ASSERT_EQ(2u, third_pass_quad_list.size());
     TestQuadMatchesExpectations(embedded_quads[1][0],
                                 third_pass_quad_list.ElementAt(0));
 
     // This render pass pass quad will reference the first pass from the
@@ skipping 448 matching lines @@
     };
     test::Pass child_passes[] = {
         test::Pass(child_quads[0], arraysize(child_quads[0]), child_pass_id[0]),
         test::Pass(child_quads[1], arraysize(child_quads[1]),
                    child_pass_id[1])};
 
     RenderPassList child_pass_list;
     AddPasses(&child_pass_list, gfx::Rect(SurfaceSize()), child_passes,
               arraysize(child_passes));
 
-    RenderPass* child_nonroot_pass = child_pass_list.at(0u);
+    RenderPass* child_nonroot_pass = child_pass_list[0].get();
     child_nonroot_pass->transform_to_root_target.Translate(8, 0);
     SharedQuadState* child_nonroot_pass_sqs =
         child_nonroot_pass->shared_quad_state_list.front();
     child_nonroot_pass_sqs->quad_to_target_transform.Translate(5, 0);
 
-    RenderPass* child_root_pass = child_pass_list.at(1u);
+    RenderPass* child_root_pass = child_pass_list[1].get();
     SharedQuadState* child_root_pass_sqs =
         child_root_pass->shared_quad_state_list.front();
     child_root_pass_sqs->quad_to_target_transform.Translate(8, 0);
     child_root_pass_sqs->is_clipped = true;
     child_root_pass_sqs->clip_rect = gfx::Rect(0, 0, 5, 5);
 
     scoped_ptr<DelegatedFrameData> child_frame_data(new DelegatedFrameData);
     child_pass_list.swap(child_frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
@@ skipping 12 matching lines @@
     test::Quad middle_quads[] = {
         test::Quad::SurfaceQuad(child_surface_id, 1.f)};
     test::Pass middle_passes[] = {
         test::Pass(middle_quads, arraysize(middle_quads)),
     };
 
     RenderPassList middle_pass_list;
     AddPasses(&middle_pass_list, gfx::Rect(SurfaceSize()), middle_passes,
               arraysize(middle_passes));
 
-    RenderPass* middle_root_pass = middle_pass_list.at(0u);
+    RenderPass* middle_root_pass = middle_pass_list[0].get();
     middle_root_pass->quad_list.ElementAt(0)->visible_rect =
         gfx::Rect(0, 1, 100, 7);
     SharedQuadState* middle_root_pass_sqs =
         middle_root_pass->shared_quad_state_list.front();
     middle_root_pass_sqs->quad_to_target_transform.Scale(2, 3);
 
     scoped_ptr<DelegatedFrameData> middle_frame_data(new DelegatedFrameData);
     middle_pass_list.swap(middle_frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> middle_frame(new CompositorFrame);
@@ skipping 11 matching lines @@
   test::Pass root_passes[] = {
       test::Pass(secondary_quads, arraysize(secondary_quads)),
       test::Pass(root_quads, arraysize(root_quads))};
 
   RenderPassList root_pass_list;
   AddPasses(&root_pass_list,
             gfx::Rect(SurfaceSize()),
             root_passes,
             arraysize(root_passes));
 
-  root_pass_list.at(0)
+  root_pass_list[0]
       ->shared_quad_state_list.front()
       ->quad_to_target_transform.Translate(0, 7);
-  root_pass_list.at(0)
+  root_pass_list[0]
       ->shared_quad_state_list.ElementAt(1)
       ->quad_to_target_transform.Translate(0, 10);
-  root_pass_list.at(0)->quad_list.ElementAt(1)->visible_rect =
+  root_pass_list[0]->quad_list.ElementAt(1)->visible_rect =
       gfx::Rect(0, 0, 8, 100);
 
   root_pass_list[0]->transform_to_root_target.Translate(10, 5);
 
   scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
   root_pass_list.swap(root_frame_data->render_pass_list);
 
   scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
   root_frame->delegated_frame_data = root_frame_data.Pass();
 
@@ skipping 94 matching lines @@
   test::Quad child_quads[] = {test::Quad::RenderPassQuad(RenderPassId(1, 1))};
   test::Pass child_passes[] = {
       test::Pass(child_quads, arraysize(child_quads), RenderPassId(1, 1))};
 
   RenderPassList child_pass_list;
   AddPasses(&child_pass_list,
             gfx::Rect(SurfaceSize()),
             child_passes,
             arraysize(child_passes));
 
-  RenderPass* child_root_pass = child_pass_list.at(0u);
+  RenderPass* child_root_pass = child_pass_list[0].get();
   SharedQuadState* child_root_pass_sqs =
       child_root_pass->shared_quad_state_list.front();
   child_root_pass_sqs->quad_to_target_transform.Translate(8, 0);
 
   scoped_ptr<DelegatedFrameData> child_frame_data(new DelegatedFrameData);
   child_pass_list.swap(child_frame_data->render_pass_list);
 
   scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
   child_frame->delegated_frame_data = child_frame_data.Pass();
 
@@ skipping 40 matching lines @@
                  RenderPassId(1, 1)),
       test::Pass(root_render_pass_quads, arraysize(root_render_pass_quads),
                  RenderPassId(2, 1))};
 
   RenderPassList root_pass_list;
   AddPasses(&root_pass_list,
             gfx::Rect(SurfaceSize()),
             root_passes,
             arraysize(root_passes));
 
-  root_pass_list.at(0)
+  root_pass_list[0]
       ->shared_quad_state_list.front()
       ->quad_to_target_transform.Translate(0, 10);
-  root_pass_list.at(0)->damage_rect = gfx::Rect(5, 5, 10, 10);
-  root_pass_list.at(1)->damage_rect = gfx::Rect(5, 5, 100, 100);
+  root_pass_list[0]->damage_rect = gfx::Rect(5, 5, 10, 10);
+  root_pass_list[1]->damage_rect = gfx::Rect(5, 5, 100, 100);
 
   scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
   root_pass_list.swap(root_frame_data->render_pass_list);
 
   scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
   root_frame->delegated_frame_data = root_frame_data.Pass();
 
   factory_.SubmitCompositorFrame(root_surface_id_, root_frame.Pass(),
                                  SurfaceFactory::DrawCallback());
 
@@ skipping 20 matching lines @@
   // Damage rect for first aggregation should contain entire root surface.
   EXPECT_TRUE(
       aggregated_pass_list[1]->damage_rect.Contains(gfx::Rect(SurfaceSize())));
 
   {
     AddPasses(&child_pass_list,
               gfx::Rect(SurfaceSize()),
               child_passes,
               arraysize(child_passes));
 
-    RenderPass* child_root_pass = child_pass_list.at(0u);
+    RenderPass* child_root_pass = child_pass_list[0].get();
     SharedQuadState* child_root_pass_sqs =
         child_root_pass->shared_quad_state_list.front();
     child_root_pass_sqs->quad_to_target_transform.Translate(8, 0);
     child_root_pass->damage_rect = gfx::Rect(10, 10, 10, 10);
 
     scoped_ptr<DelegatedFrameData> child_frame_data(new DelegatedFrameData);
     child_pass_list.swap(child_frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> child_frame(new CompositorFrame);
     child_frame->delegated_frame_data = child_frame_data.Pass();
@@ skipping 28 matching lines @@
               aggregated_pass_list[1]->damage_rect.ToString());
   }
 
   {
     RenderPassList root_pass_list;
     AddPasses(&root_pass_list,
               gfx::Rect(SurfaceSize()),
               root_passes,
               arraysize(root_passes));
 
-    root_pass_list.at(0)
+    root_pass_list[0]
         ->shared_quad_state_list.front()
         ->quad_to_target_transform.Translate(0, 10);
-    root_pass_list.at(0)->damage_rect = gfx::Rect(0, 0, 1, 1);
+    root_pass_list[0]->damage_rect = gfx::Rect(0, 0, 1, 1);
 
     scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
     root_pass_list.swap(root_frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
     root_frame->delegated_frame_data = root_frame_data.Pass();
 
     factory_.SubmitCompositorFrame(root_surface_id_, root_frame.Pass(),
                                    SurfaceFactory::DrawCallback());
   }
 
   {
     RenderPassList root_pass_list;
     AddPasses(&root_pass_list,
               gfx::Rect(SurfaceSize()),
               root_passes,
               arraysize(root_passes));
 
-    root_pass_list.at(0)
+    root_pass_list[0]
         ->shared_quad_state_list.front()
         ->quad_to_target_transform.Translate(0, 10);
-    root_pass_list.at(0)->damage_rect = gfx::Rect(1, 1, 1, 1);
+    root_pass_list[0]->damage_rect = gfx::Rect(1, 1, 1, 1);
 
     scoped_ptr<DelegatedFrameData> root_frame_data(new DelegatedFrameData);
     root_pass_list.swap(root_frame_data->render_pass_list);
 
     scoped_ptr<CompositorFrame> root_frame(new CompositorFrame);
     root_frame->delegated_frame_data = root_frame_data.Pass();
 
     factory_.SubmitCompositorFrame(root_surface_id_, root_frame.Pass(),
                                    SurfaceFactory::DrawCallback());
 
@@ skipping 102 matching lines @@
     test::Quad child_quads1[] = {test::Quad::RenderPassQuad(child_pass_id)};
     test::Quad child_quads2[] = {test::Quad::RenderPassQuad(child_pass_id)};
     test::Pass child_passes[] = {
         test::Pass(child_quads1, arraysize(child_quads1), child_pass_id),
         test::Pass(child_quads2, arraysize(child_quads2), child_pass_id)};
 
     RenderPassList child_pass_list;
     AddPasses(&child_pass_list, gfx::Rect(SurfaceSize()), child_passes,
               arraysize(child_passes));
 
-    child_pass_list.at(0u)->quad_list.ElementAt(0)->visible_rect =
+    child_pass_list[0]->quad_list.ElementAt(0)->visible_rect =
         gfx::Rect(1, 1, 2, 2);
     SharedQuadState* child_sqs =
-        child_pass_list.at(0u)->shared_quad_state_list.ElementAt(0u);
+        child_pass_list[0]->shared_quad_state_list.ElementAt(0u);
     child_sqs->quad_to_target_transform.Translate(1, 1);
     child_sqs->quad_to_target_transform.Scale(2, 2);
 
-    child_pass_list.at(1u)->quad_list.ElementAt(0)->visible_rect =
+    child_pass_list[1]->quad_list.ElementAt(0)->visible_rect =
         gfx::Rect(0, 0, 2, 2);
 
     SubmitPassListAsFrame(child_surface_id, &child_pass_list);
   }
 
   {
     test::Quad root_quads[] = {test::Quad::SurfaceQuad(child_surface_id, 1.f)};
 
     test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))};
 
     RenderPassList root_pass_list;
     AddPasses(&root_pass_list, gfx::Rect(SurfaceSize()), root_passes,
               arraysize(root_passes));
 
-    RenderPass* root_pass = root_pass_list.at(0u);
+    RenderPass* root_pass = root_pass_list[0].get();
     root_pass->shared_quad_state_list.front()
         ->quad_to_target_transform.Translate(10, 10);
     root_pass->damage_rect = gfx::Rect(0, 0, 1, 1);
 
     SubmitPassListAsFrame(root_surface_id_, &root_pass_list);
   }
 
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(root_surface_));
   EXPECT_FALSE(surface_aggregator_client_.HasSurface(child_surface));
 
@@ skipping 20 matching lines @@
   // Create a root surface with a smaller damage rect.
   {
     test::Quad root_quads[] = {test::Quad::SurfaceQuad(child_surface_id, 1.f)};
 
     test::Pass root_passes[] = {test::Pass(root_quads, arraysize(root_quads))};
 
     RenderPassList root_pass_list;
     AddPasses(&root_pass_list, gfx::Rect(SurfaceSize()), root_passes,
               arraysize(root_passes));
 
-    RenderPass* root_pass = root_pass_list.at(0u);
+    RenderPass* root_pass = root_pass_list[0].get();
     root_pass->shared_quad_state_list.front()
         ->quad_to_target_transform.Translate(10, 10);
     root_pass->damage_rect = gfx::Rect(10, 10, 2, 2);
     SubmitPassListAsFrame(root_surface_id_, &root_pass_list);
   }
 
   {
     EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
     EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
 
@@ skipping 29 matching lines @@
     test::Quad child_quads1[] = {test::Quad::RenderPassQuad(child_pass_id)};
     test::Quad child_quads2[] = {test::Quad::RenderPassQuad(child_pass_id)};
     test::Pass child_passes[] = {
         test::Pass(child_quads1, arraysize(child_quads1), child_pass_id),
         test::Pass(child_quads2, arraysize(child_quads2), child_pass_id)};
 
     RenderPassList child_pass_list;
     AddPasses(&child_pass_list, gfx::Rect(SurfaceSize()), child_passes,
               arraysize(child_passes));
 
-    child_pass_list.at(0u)->quad_list.ElementAt(0)->visible_rect =
+    child_pass_list[0]->quad_list.ElementAt(0)->visible_rect =
         gfx::Rect(1, 1, 2, 2);
     SharedQuadState* child_sqs =
-        child_pass_list.at(0u)->shared_quad_state_list.ElementAt(0u);
+        child_pass_list[0]->shared_quad_state_list.ElementAt(0u);
     child_sqs->quad_to_target_transform.Translate(1, 1);
     child_sqs->quad_to_target_transform.Scale(2, 2);
 
-    child_pass_list.at(1u)->quad_list.ElementAt(0)->visible_rect =
+    child_pass_list[1]->quad_list.ElementAt(0)->visible_rect =
         gfx::Rect(0, 0, 2, 2);
 
-    RenderPass* child_root_pass = child_pass_list.at(1u);
+    RenderPass* child_root_pass = child_pass_list[1].get();
 
     child_root_pass->copy_requests.push_back(
         CopyOutputRequest::CreateEmptyRequest());
     child_root_pass->damage_rect = gfx::Rect();
     SubmitPassListAsFrame(child_surface_id, &child_pass_list);
   }
 
   {
     EXPECT_TRUE(surface_aggregator_client_.HasSurface(root_surface_));
     EXPECT_TRUE(surface_aggregator_client_.HasSurface(child_surface));
@@ skipping 344 matching lines @@
   EXPECT_EQ(9u, pass_list->back()->quad_list.size());
 
   factory.Destroy(root_surface_id);
   factory.Destroy(child_surface_id);
   factory.Destroy(middle_surface_id);
 }
 
 }  // namespace
 }  // namespace cc