Use RenderPass to create DrawQuad in unittests

content/common/cc_messages_unittest.cc

 // Copyright (c) 2012 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 "content/common/cc_messages.h"
 
 #include <string.h>
 
 #include <algorithm>
 
@@ skipping 289 matching lines @@
   pass_cmp->SetAll(arbitrary_id,
                    arbitrary_rect1,
                    arbitrary_rect2,
                    arbitrary_matrix,
                    arbitrary_bool1);
 
   SharedQuadState* shared_state1_cmp =
       pass_cmp->CreateAndAppendSharedQuadState();
   shared_state1_cmp->CopyFrom(shared_state1_in);
 
-  scoped_ptr<CheckerboardDrawQuad> checkerboard_in =
-      CheckerboardDrawQuad::Create();
+  CheckerboardDrawQuad* checkerboard_in =
+      pass_in->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
   checkerboard_in->SetAll(shared_state1_in,
                           arbitrary_rect1,
                           arbitrary_rect2_inside_rect1,
                           arbitrary_rect1_inside_rect1,
                           arbitrary_bool1,
                           arbitrary_color);
-  scoped_ptr<DrawQuad> checkerboard_cmp = checkerboard_in->Copy(
-      checkerboard_in->shared_quad_state);
+  CheckerboardDrawQuad* checkerboard_cmp =
+      pass_cmp->CopyFromAndAppendDrawQuad<CheckerboardDrawQuad>(
+          checkerboard_in);
+  checkerboard_cmp->shared_quad_state = checkerboard_in->shared_quad_state;
 
-  scoped_ptr<DebugBorderDrawQuad> debugborder_in =
-      DebugBorderDrawQuad::Create();
+  DebugBorderDrawQuad* debugborder_in =
+      pass_in->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
   debugborder_in->SetAll(shared_state1_in,
                          arbitrary_rect3,
                          arbitrary_rect1_inside_rect3,
                          arbitrary_rect2_inside_rect3,
                          arbitrary_bool1,
                          arbitrary_color,
                          arbitrary_int);
-  scoped_ptr<DrawQuad> debugborder_cmp = debugborder_in->Copy(
-      debugborder_in->shared_quad_state);
+  DebugBorderDrawQuad* debugborder_cmp =
+      pass_cmp->CopyFromAndAppendDrawQuad<DebugBorderDrawQuad>(debugborder_in);
+  debugborder_cmp->shared_quad_state = debugborder_in->shared_quad_state;
 
-  scoped_ptr<IOSurfaceDrawQuad> iosurface_in =
-      IOSurfaceDrawQuad::Create();
+  IOSurfaceDrawQuad* iosurface_in =
+      pass_in->CreateAndAppendDrawQuad<IOSurfaceDrawQuad>();
   iosurface_in->SetAll(shared_state1_in,
                        arbitrary_rect2,
                        arbitrary_rect2_inside_rect2,
                        arbitrary_rect1_inside_rect2,
                        arbitrary_bool1,
                        arbitrary_size1,
                        arbitrary_resourceid3,
                        arbitrary_orientation);
-  scoped_ptr<DrawQuad> iosurface_cmp = iosurface_in->Copy(
-      iosurface_in->shared_quad_state);
+  IOSurfaceDrawQuad* iosurface_cmp =
+      pass_cmp->CopyFromAndAppendDrawQuad<IOSurfaceDrawQuad>(iosurface_in);
+  iosurface_cmp->shared_quad_state = iosurface_in->shared_quad_state;
 
   SharedQuadState* shared_state2_in = pass_in->CreateAndAppendSharedQuadState();
   shared_state2_in->SetAll(arbitrary_matrix,
                            arbitrary_size2,
                            arbitrary_rect2,
                            arbitrary_rect3,
                            arbitrary_bool1,
                            arbitrary_float2,
                            arbitrary_blend_mode2,
                            arbitrary_context_id2);
   SharedQuadState* shared_state2_cmp =
       pass_cmp->CreateAndAppendSharedQuadState();
   shared_state2_cmp->CopyFrom(shared_state2_in);
 
-  scoped_ptr<RenderPassDrawQuad> renderpass_in =
-      RenderPassDrawQuad::Create();
+  RenderPassDrawQuad* renderpass_in =
+      pass_in->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   renderpass_in->SetAll(shared_state2_in,
                         arbitrary_rect1,
                         arbitrary_rect2_inside_rect1,
                         arbitrary_rect1_inside_rect1,
                         arbitrary_bool1,
                         arbitrary_id,
                         arbitrary_bool2,
                         arbitrary_resourceid2,
                         arbitrary_rect1,
                         arbitrary_rectf1,
                         arbitrary_filters1,
                         arbitrary_filters2);
-  scoped_ptr<RenderPassDrawQuad> renderpass_cmp = renderpass_in->Copy(
-      renderpass_in->shared_quad_state, renderpass_in->render_pass_id);
+  RenderPassDrawQuad* renderpass_cmp =
+      pass_cmp->CopyFromAndAppendDrawQuad<RenderPassDrawQuad>(renderpass_in);
+  renderpass_cmp->shared_quad_state = renderpass_in->shared_quad_state;
+  renderpass_cmp->render_pass_id = renderpass_in->render_pass_id;
 
   SharedQuadState* shared_state3_in = pass_in->CreateAndAppendSharedQuadState();
   shared_state3_in->SetAll(arbitrary_matrix,
                            arbitrary_size3,
                            arbitrary_rect3,
                            arbitrary_rect1,
                            arbitrary_bool1,
                            arbitrary_float3,
                            arbitrary_blend_mode3,
                            arbitrary_context_id3);
   SharedQuadState* shared_state3_cmp =
       pass_cmp->CreateAndAppendSharedQuadState();
   shared_state3_cmp->CopyFrom(shared_state3_in);
 
-  scoped_ptr<SolidColorDrawQuad> solidcolor_in =
-      SolidColorDrawQuad::Create();
+  SolidColorDrawQuad* solidcolor_in =
+      pass_in->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   solidcolor_in->SetAll(shared_state3_in,
                         arbitrary_rect3,
                         arbitrary_rect1_inside_rect3,
                         arbitrary_rect2_inside_rect3,
                         arbitrary_bool1,
                         arbitrary_color,
                         arbitrary_bool2);
-  scoped_ptr<DrawQuad> solidcolor_cmp = solidcolor_in->Copy(
-      solidcolor_in->shared_quad_state);
+  SolidColorDrawQuad* solidcolor_cmp =
+      pass_cmp->CopyFromAndAppendDrawQuad<SolidColorDrawQuad>(solidcolor_in);
+  solidcolor_cmp->shared_quad_state = solidcolor_in->shared_quad_state;
 
-  scoped_ptr<StreamVideoDrawQuad> streamvideo_in =
-      StreamVideoDrawQuad::Create();
+  StreamVideoDrawQuad* streamvideo_in =
+      pass_in->CreateAndAppendDrawQuad<StreamVideoDrawQuad>();
   streamvideo_in->SetAll(shared_state3_in,
                          arbitrary_rect2,
                          arbitrary_rect2_inside_rect2,
                          arbitrary_rect1_inside_rect2,
                          arbitrary_bool1,
                          arbitrary_resourceid2,
                          arbitrary_matrix);
-  scoped_ptr<DrawQuad> streamvideo_cmp = streamvideo_in->Copy(
-      streamvideo_in->shared_quad_state);
+  StreamVideoDrawQuad* streamvideo_cmp =
+      pass_cmp->CopyFromAndAppendDrawQuad<StreamVideoDrawQuad>(streamvideo_in);
+  streamvideo_cmp->shared_quad_state = streamvideo_in->shared_quad_state;
 
   cc::SurfaceId arbitrary_surface_id(3);
-  scoped_ptr<SurfaceDrawQuad> surface_in = SurfaceDrawQuad::Create();
+  SurfaceDrawQuad* surface_in =
+      pass_in->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   surface_in->SetAll(shared_state3_in,
                      arbitrary_rect2,
                      arbitrary_rect2_inside_rect2,
                      arbitrary_rect1_inside_rect2,
                      arbitrary_bool1,
                      arbitrary_surface_id);
-  scoped_ptr<DrawQuad> surface_cmp = surface_in->Copy(
-      surface_in->shared_quad_state);
+  SurfaceDrawQuad* surface_cmp =
+      pass_cmp->CopyFromAndAppendDrawQuad<SurfaceDrawQuad>(surface_in);
+  surface_cmp->shared_quad_state = surface_in->shared_quad_state;
 
-  scoped_ptr<TextureDrawQuad> texture_in = TextureDrawQuad::Create();
+  TextureDrawQuad* texture_in =
+      pass_in->CreateAndAppendDrawQuad<TextureDrawQuad>();
   texture_in->SetAll(shared_state3_in,
                      arbitrary_rect2,
                      arbitrary_rect2_inside_rect2,
                      arbitrary_rect1_inside_rect2,
                      arbitrary_bool1,
                      arbitrary_resourceid1,
                      arbitrary_bool2,
                      arbitrary_pointf1,
                      arbitrary_pointf2,
                      arbitrary_color,
                      arbitrary_float_array,
                      arbitrary_bool3);
-  scoped_ptr<DrawQuad> texture_cmp = texture_in->Copy(
-      texture_in->shared_quad_state);
+  TextureDrawQuad* texture_cmp =
+      pass_cmp->CopyFromAndAppendDrawQuad<TextureDrawQuad>(texture_in);
+  texture_cmp->shared_quad_state = texture_in->shared_quad_state;
 
-  scoped_ptr<TileDrawQuad> tile_in = TileDrawQuad::Create();
+  TileDrawQuad* tile_in = pass_in->CreateAndAppendDrawQuad<TileDrawQuad>();
   tile_in->SetAll(shared_state3_in,
                   arbitrary_rect2,
                   arbitrary_rect2_inside_rect2,
                   arbitrary_rect1_inside_rect2,
                   arbitrary_bool1,
                   arbitrary_resourceid3,
                   arbitrary_rectf1,
                   arbitrary_size1,
                   arbitrary_bool2);
-  scoped_ptr<DrawQuad> tile_cmp = tile_in->Copy(
-      tile_in->shared_quad_state);
+  TileDrawQuad* tile_cmp =
+      pass_cmp->CopyFromAndAppendDrawQuad<TileDrawQuad>(tile_in);
+  tile_cmp->shared_quad_state = tile_in->shared_quad_state;
 
-  scoped_ptr<YUVVideoDrawQuad> yuvvideo_in =
-      YUVVideoDrawQuad::Create();
+  YUVVideoDrawQuad* yuvvideo_in =
+      pass_in->CreateAndAppendDrawQuad<YUVVideoDrawQuad>();
   yuvvideo_in->SetAll(shared_state3_in,
                       arbitrary_rect1,
                       arbitrary_rect2_inside_rect1,
                       arbitrary_rect1_inside_rect1,
                       arbitrary_bool1,
                       arbitrary_rectf1,
                       arbitrary_resourceid1,
                       arbitrary_resourceid2,
                       arbitrary_resourceid3,
                       arbitrary_resourceid4,
                       arbitrary_color_space);
-  scoped_ptr<DrawQuad> yuvvideo_cmp = yuvvideo_in->Copy(
-      yuvvideo_in->shared_quad_state);
-
-  pass_in->quad_list.push_back(checkerboard_in.PassAs<DrawQuad>());
-  pass_in->quad_list.push_back(debugborder_in.PassAs<DrawQuad>());
-  pass_in->quad_list.push_back(iosurface_in.PassAs<DrawQuad>());
-  pass_in->quad_list.push_back(renderpass_in.PassAs<DrawQuad>());
-  pass_in->quad_list.push_back(solidcolor_in.PassAs<DrawQuad>());
-  pass_in->quad_list.push_back(streamvideo_in.PassAs<DrawQuad>());
-  pass_in->quad_list.push_back(surface_in.PassAs<DrawQuad>());
-  pass_in->quad_list.push_back(texture_in.PassAs<DrawQuad>());
-  pass_in->quad_list.push_back(tile_in.PassAs<DrawQuad>());
-  pass_in->quad_list.push_back(yuvvideo_in.PassAs<DrawQuad>());
-
-
-  pass_cmp->quad_list.push_back(checkerboard_cmp.PassAs<DrawQuad>());
-  pass_cmp->quad_list.push_back(debugborder_cmp.PassAs<DrawQuad>());
-  pass_cmp->quad_list.push_back(iosurface_cmp.PassAs<DrawQuad>());
-  pass_cmp->quad_list.push_back(renderpass_cmp.PassAs<DrawQuad>());
-  pass_cmp->quad_list.push_back(solidcolor_cmp.PassAs<DrawQuad>());
-  pass_cmp->quad_list.push_back(streamvideo_cmp.PassAs<DrawQuad>());
-  pass_cmp->quad_list.push_back(surface_cmp.PassAs<DrawQuad>());
-  pass_cmp->quad_list.push_back(texture_cmp.PassAs<DrawQuad>());
-  pass_cmp->quad_list.push_back(tile_cmp.PassAs<DrawQuad>());
-  pass_cmp->quad_list.push_back(yuvvideo_cmp.PassAs<DrawQuad>());
+  YUVVideoDrawQuad* yuvvideo_cmp =
+      pass_cmp->CopyFromAndAppendDrawQuad<YUVVideoDrawQuad>(yuvvideo_in);
+  yuvvideo_cmp->shared_quad_state = yuvvideo_in->shared_quad_state;
 
   // Make sure the in and cmp RenderPasses match.
   Compare(pass_cmp.get(), pass_in.get());
   ASSERT_EQ(3u, pass_in->shared_quad_state_list.size());
   ASSERT_EQ(10u, pass_in->quad_list.size());
   for (size_t i = 0; i < 3; ++i) {
     Compare(pass_cmp->shared_quad_state_list[i],
             pass_in->shared_quad_state_list[i]);
   }
   for (size_t i = 0; i < pass_in->quad_list.size(); ++i)
@@ skipping 35 matching lines @@
         pass_cmp->quad_list[i]->shared_quad_state ==
         pass_cmp->quad_list[i - 1]->shared_quad_state;
     bool same_shared_quad_state_out =
         pass_out->quad_list[i]->shared_quad_state ==
         pass_out->quad_list[i - 1]->shared_quad_state;
     EXPECT_EQ(same_shared_quad_state_cmp, same_shared_quad_state_out);
   }
 }
 
 TEST_F(CCMessagesTest, UnusedSharedQuadStates) {
-  scoped_ptr<CheckerboardDrawQuad> quad;
-
   scoped_ptr<RenderPass> pass_in = RenderPass::Create();
   pass_in->SetAll(RenderPass::Id(1, 1),
                   gfx::Rect(100, 100),
                   gfx::Rect(),
                   gfx::Transform(),
                   false);
 
   // The first SharedQuadState is used.
   SharedQuadState* shared_state1_in = pass_in->CreateAndAppendSharedQuadState();
   shared_state1_in->SetAll(gfx::Transform(),
                            gfx::Size(1, 1),
                            gfx::Rect(),
                            gfx::Rect(),
                            false,
                            1.f,
                            SkXfermode::kSrcOver_Mode,
                            0);
 
-  quad = CheckerboardDrawQuad::Create();
-  quad->SetAll(shared_state1_in,
-               gfx::Rect(10, 10),
-               gfx::Rect(10, 10),
-               gfx::Rect(10, 10),
-               false,
-               SK_ColorRED);
-  pass_in->quad_list.push_back(quad.PassAs<DrawQuad>());
+  CheckerboardDrawQuad* quad1 =
+      pass_in->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
+  quad1->SetAll(shared_state1_in,
+                gfx::Rect(10, 10),
+                gfx::Rect(10, 10),
+                gfx::Rect(10, 10),
+                false,
+                SK_ColorRED);
 
   // The second and third SharedQuadStates are not used.
   SharedQuadState* shared_state2_in = pass_in->CreateAndAppendSharedQuadState();
   shared_state2_in->SetAll(gfx::Transform(),
                            gfx::Size(2, 2),
                            gfx::Rect(),
                            gfx::Rect(),
                            false,
                            1.f,
                            SkXfermode::kSrcOver_Mode,
@@ skipping 13 matching lines @@
   SharedQuadState* shared_state4_in = pass_in->CreateAndAppendSharedQuadState();
   shared_state4_in->SetAll(gfx::Transform(),
                            gfx::Size(4, 4),
                            gfx::Rect(),
                            gfx::Rect(),
                            false,
                            1.f,
                            SkXfermode::kSrcOver_Mode,
                            0);
 
-  quad = CheckerboardDrawQuad::Create();
-  quad->SetAll(shared_state4_in,
-               gfx::Rect(10, 10),
-               gfx::Rect(10, 10),
-               gfx::Rect(10, 10),
-               false,
-               SK_ColorRED);
-  pass_in->quad_list.push_back(quad.PassAs<DrawQuad>());
+  CheckerboardDrawQuad* quad2 =
+      pass_in->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
+  quad2->SetAll(shared_state4_in,
+                gfx::Rect(10, 10),
+                gfx::Rect(10, 10),
+                gfx::Rect(10, 10),
+                false,
+                SK_ColorRED);
 
   // The fifth is not used again.
   SharedQuadState* shared_state5_in = pass_in->CreateAndAppendSharedQuadState();
   shared_state5_in->SetAll(gfx::Transform(),
                            gfx::Size(5, 5),
                            gfx::Rect(),
                            gfx::Rect(),
                            false,
                            1.f,
                            SkXfermode::kSrcOver_Mode,
@@ skipping 195 matching lines @@
     SoftwareFrameData frame_out;
     PickleIterator iter(msg);
     EXPECT_EQ(
         expect_read,
         IPC::ParamTraits<SoftwareFrameData>::Read(&msg, &iter, &frame_out));
   }
 }
 
 }  // namespace
 }  // namespace content