Use Custome ListContainer to Allocate SharedQuadState

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 727 matching lines @@
 
   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);
   child_nonroot_pass->transform_to_root_target.Translate(8, 0);
   SharedQuadState* child_nonroot_pass_sqs =
-      child_nonroot_pass->shared_quad_state_list[0];
+      child_nonroot_pass->shared_quad_state_list.front();
   child_nonroot_pass_sqs->content_to_target_transform.Translate(5, 0);
 
   RenderPass* child_root_pass = child_pass_list.at(1u);
   SharedQuadState* child_root_pass_sqs =
-      child_root_pass->shared_quad_state_list[0];
+      child_root_pass->shared_quad_state_list.front();
   child_root_pass_sqs->content_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);
   child_frame->delegated_frame_data = child_frame_data.Pass();
 
   factory_.SubmitFrame(child_surface_id, child_frame.Pass(), base::Closure());
 
   test::Quad root_quads[] = {test::Quad::SolidColorQuad(1),
                              test::Quad::SurfaceQuad(child_surface_id)};
   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));
 
   root_pass_list.at(0)
-      ->shared_quad_state_list[0]
+      ->shared_quad_state_list.front()
       ->content_to_target_transform.Translate(0, 7);
   root_pass_list.at(0)
-      ->shared_quad_state_list[1]
+      ->shared_quad_state_list.ElementAt(1)
       ->content_to_target_transform.Translate(0, 10);
 
   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_.SubmitFrame(root_surface_id_, root_frame.Pass(), base::Closure());
 
@@ skipping 50 matching lines @@
   size_t i = 0;
   for (QuadList::Iterator iter = aggregated_pass_list[1]->quad_list.begin();
        iter != aggregated_pass_list[1]->quad_list.end();
        ++iter) {
     EXPECT_EQ(expected_root_pass_quad_transforms[i].ToString(),
               iter->quadTransform().ToString())
         << i;
     i++;
   }
 
-  EXPECT_EQ(true,
-            aggregated_pass_list[1]->shared_quad_state_list[1]->is_clipped);
+  SharedQuadStateList::Iterator sqs_iter =
+      aggregated_pass_list[1]->shared_quad_state_list.begin();
+  ++sqs_iter;

[danakj, 2014/09/26 20:40:55]

ElementAt

[weiliangc, 2014/10/01 23:02:00]

Done.

+  EXPECT_EQ(true, sqs_iter->is_clipped);
 
   // The second quad in the root pass is aggregated from the child, so its
   // clip rect must be transformed by the child's translation.
-  EXPECT_EQ(
-      gfx::Rect(0, 10, 5, 5).ToString(),
-      aggregated_pass_list[1]->shared_quad_state_list[1]->clip_rect.ToString());
+  EXPECT_EQ(gfx::Rect(0, 10, 5, 5).ToString(), sqs_iter->clip_rect.ToString());

[danakj, 2014/09/26 20:40:55]

ElementAt

[weiliangc, 2014/10/01 23:02:00]

Done.

 
   factory_.Destroy(child_surface_id);
 }
 
 // Tests that damage rects are aggregated correctly when surfaces change.
 TEST_F(SurfaceAggregatorValidSurfaceTest, AggregateDamageRect) {
   SurfaceId child_surface_id = allocator_.GenerateId();
   factory_.Create(child_surface_id, SurfaceSize());
   RenderPassId child_pass_id = RenderPassId(1, 1);
   test::Quad child_quads[] = {test::Quad::RenderPassQuad(child_pass_id)};
   test::Pass child_passes[] = {
       test::Pass(child_quads, arraysize(child_quads), child_pass_id)};
 
   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);
   SharedQuadState* child_root_pass_sqs =
-      child_root_pass->shared_quad_state_list[0];
+      child_root_pass->shared_quad_state_list.front();
   child_root_pass_sqs->content_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();
 
   factory_.SubmitFrame(child_surface_id, child_frame.Pass(), base::Closure());
 
   test::Quad root_quads[] = {test::Quad::SurfaceQuad(child_surface_id)};
   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));
 
   root_pass_list.at(0)
-      ->shared_quad_state_list[0]
+      ->shared_quad_state_list.front()
       ->content_to_target_transform.Translate(0, 10);
   root_pass_list.at(0)->damage_rect = gfx::Rect(5, 5, 10, 10);
 
   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_.SubmitFrame(root_surface_id_, root_frame.Pass(), base::Closure());
@@ skipping 15 matching lines @@
       aggregated_pass_list[0]->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);
     SharedQuadState* child_root_pass_sqs =
-        child_root_pass->shared_quad_state_list[0];
+        child_root_pass->shared_quad_state_list.front();
     child_root_pass_sqs->content_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();
 
     factory_.SubmitFrame(child_surface_id, child_frame.Pass(), base::Closure());
@@ skipping 18 matching lines @@
   }
 
   {
     RenderPassList root_pass_list;
     AddPasses(&root_pass_list,
               gfx::Rect(SurfaceSize()),
               root_passes,
               arraysize(root_passes));
 
     root_pass_list.at(0)
-        ->shared_quad_state_list[0]
+        ->shared_quad_state_list.front()
         ->content_to_target_transform.Translate(0, 10);
     root_pass_list.at(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_.SubmitFrame(root_surface_id_, root_frame.Pass(), base::Closure());
   }
 
   {
     RenderPassList root_pass_list;
     AddPasses(&root_pass_list,
               gfx::Rect(SurfaceSize()),
               root_passes,
               arraysize(root_passes));
 
     root_pass_list.at(0)
-        ->shared_quad_state_list[0]
+        ->shared_quad_state_list.front()
         ->content_to_target_transform.Translate(0, 10);
     root_pass_list.at(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_.SubmitFrame(root_surface_id_, root_frame.Pass(), base::Closure());
@@ skipping 138 matching lines @@
     returned_ids[i] = client.returned_resources()[i].id;
   }
   EXPECT_THAT(returned_ids,
               testing::WhenSorted(testing::ElementsAreArray(ids)));
   factory.Destroy(surface_id);
 }
 
 }  // namespace
 }  // namespace cc