Use RenderPass to create DrawQuad in unittests

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 469 matching lines @@
   SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
   sqs->SetAll(content_to_target_transform,
               content_bounds,
               visible_content_rect,
               clip_rect,
               is_clipped,
               opacity,
               blend_mode,
               0);
 
-  scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
+  SolidColorDrawQuad* color_quad =
+      pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   color_quad->SetNew(pass->shared_quad_state_list.back(),
                      visible_content_rect,
                      visible_content_rect,
                      SK_ColorGREEN,
                      force_anti_aliasing_off);
-  pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
 }
 
 // This tests that we update shared quad state pointers correctly within
 // aggregated passes.  The shared quad state list on the aggregated pass will
 // include the shared quad states from each pass in one list so the quads will
 // end up pointed to shared quad state objects at different offsets. This test
 // uses the blend_mode value stored on the shared quad state to track the shared
 // quad state, but anything saved on the shared quad state would work.
 //
 // This test has 4 surfaces in the following structure:
@@ skipping 40 matching lines @@
   QueuePassAsFrame(grandchild_pass.Pass(), grandchild_surface_id);
 
   SurfaceId child_one_surface_id = allocator_.GenerateId();
   factory_.Create(child_one_surface_id, SurfaceSize());
 
   scoped_ptr<RenderPass> child_one_pass = RenderPass::Create();
   child_one_pass->SetNew(
       pass_id, output_rect, damage_rect, transform_to_root_target);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), child_one_pass.get(), blend_modes[1]);
-  scoped_ptr<SurfaceDrawQuad> grandchild_surface_quad =
-      SurfaceDrawQuad::Create();
+  SurfaceDrawQuad* grandchild_surface_quad =
+      child_one_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   grandchild_surface_quad->SetNew(child_one_pass->shared_quad_state_list.back(),
                                   gfx::Rect(SurfaceSize()),
                                   gfx::Rect(SurfaceSize()),
                                   grandchild_surface_id);
-  child_one_pass->quad_list.push_back(
-      grandchild_surface_quad.PassAs<DrawQuad>());
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), child_one_pass.get(), blend_modes[3]);
   QueuePassAsFrame(child_one_pass.Pass(), child_one_surface_id);
 
   SurfaceId child_two_surface_id = allocator_.GenerateId();
   factory_.Create(child_two_surface_id, SurfaceSize());
 
   scoped_ptr<RenderPass> child_two_pass = RenderPass::Create();
   child_two_pass->SetNew(
       pass_id, output_rect, damage_rect, transform_to_root_target);
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), child_two_pass.get(), blend_modes[5]);
   QueuePassAsFrame(child_two_pass.Pass(), child_two_surface_id);
 
   scoped_ptr<RenderPass> root_pass = RenderPass::Create();
   root_pass->SetNew(
       pass_id, output_rect, damage_rect, transform_to_root_target);
 
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), root_pass.get(), blend_modes[0]);
-  scoped_ptr<SurfaceDrawQuad> child_one_surface_quad =
-      SurfaceDrawQuad::Create();
+  SurfaceDrawQuad* child_one_surface_quad =
+      root_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   child_one_surface_quad->SetNew(root_pass->shared_quad_state_list.back(),
                                  gfx::Rect(SurfaceSize()),
                                  gfx::Rect(SurfaceSize()),
                                  child_one_surface_id);
-  root_pass->quad_list.push_back(child_one_surface_quad.PassAs<DrawQuad>());
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), root_pass.get(), blend_modes[4]);
-  scoped_ptr<SurfaceDrawQuad> child_two_surface_quad =
-      SurfaceDrawQuad::Create();
+  SurfaceDrawQuad* child_two_surface_quad =
+      root_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   child_two_surface_quad->SetNew(root_pass->shared_quad_state_list.back(),
                                  gfx::Rect(SurfaceSize()),
                                  gfx::Rect(SurfaceSize()),
                                  child_two_surface_id);
-  root_pass->quad_list.push_back(child_two_surface_quad.PassAs<DrawQuad>());
   AddSolidColorQuadWithBlendMode(
       SurfaceSize(), root_pass.get(), blend_modes[6]);
 
   QueuePassAsFrame(root_pass.Pass(), root_surface_id_);
 
   scoped_ptr<CompositorFrame> aggregated_frame =
       aggregator_.Aggregate(root_surface_id_);
 
   ASSERT_TRUE(aggregated_frame);
   ASSERT_TRUE(aggregated_frame->delegated_frame_data);
@@ skipping 205 matching lines @@
                               SurfaceFactory* factory,
                               SurfaceId surface_id) {
   scoped_ptr<DelegatedFrameData> frame_data(new DelegatedFrameData);
   scoped_ptr<RenderPass> pass = RenderPass::Create();
   SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
   for (size_t i = 0u; i < num_resource_ids; ++i) {
     TransferableResource resource;
     resource.id = resource_ids[i];
     resource.is_software = true;
     frame_data->resource_list.push_back(resource);
-    scoped_ptr<TextureDrawQuad> quad(TextureDrawQuad::Create());
+    TextureDrawQuad* quad = pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
     const gfx::Rect rect;
     const gfx::Rect opaque_rect;
     const gfx::Rect visible_rect;
     bool needs_blending = false;
     bool premultiplied_alpha = false;
     const gfx::PointF uv_top_left;
     const gfx::PointF uv_bottom_right;
     SkColor background_color = SK_ColorGREEN;
     const float vertex_opacity[4] = {0.f, 0.f, 1.f, 1.f};
     bool flipped = false;
     quad->SetAll(sqs,
                  rect,
                  opaque_rect,
                  visible_rect,
                  needs_blending,
                  resource_ids[i],
                  premultiplied_alpha,
                  uv_top_left,
                  uv_bottom_right,
                  background_color,
                  vertex_opacity,
                  flipped);
 
     quad->shared_quad_state = sqs;
-    pass->quad_list.push_back(quad.PassAs<DrawQuad>());
   }
   frame_data->render_pass_list.push_back(pass.Pass());
   scoped_ptr<CompositorFrame> frame(new CompositorFrame);
   frame->delegated_frame_data = frame_data.Pass();
   factory->SubmitFrame(surface_id, frame.Pass());
 }
 
 TEST_F(SurfaceAggregatorWithResourcesTest, TakeResourcesOneSurface) {
   ResourceTrackingSurfaceFactoryClient client;
   SurfaceFactory factory(&manager_, &client);
@@ skipping 15 matching lines @@
   ASSERT_EQ(3u, client.returned_resources().size());
   for (size_t i = 0; i < 3; ++i) {
     EXPECT_EQ(ids[i], client.returned_resources()[i].id);
   }
   factory.Destroy(surface_id);
 }
 
 }  // namespace
 }  // namespace cc