Use RenderPass to create DrawQuad in unittests

Instead of calling DQ::Create() function and then push it into
RenderPass in unittest, use RenderPass's function call to create and
append a DQ while only pass out a raw pointer instead of ownership.

Follow CL 369623002.

BUG=344962
TEST=cc_unittests, content_unittests

Review URL: https://codereview.chromium.org/368403003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@282179 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 97 insertions, 25 deletions

diff --git a/cc/quads/render_pass.cc b/cc/quads/render_pass.cc
index 61fcb25..7016166 100644
--- a/cc/quads/render_pass.cc
+++ b/cc/quads/render_pass.cc
@@ -8,9 +8,19 @@
 #include "cc/base/math_util.h"
 #include "cc/debug/traced_value.h"
 #include "cc/output/copy_output_request.h"
+#include "cc/quads/checkerboard_draw_quad.h"
+#include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/draw_quad.h"
+#include "cc/quads/io_surface_draw_quad.h"
+#include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
+#include "cc/quads/solid_color_draw_quad.h"
+#include "cc/quads/stream_video_draw_quad.h"
+#include "cc/quads/surface_draw_quad.h"
+#include "cc/quads/texture_draw_quad.h"
+#include "cc/quads/tile_draw_quad.h"
+#include "cc/quads/yuv_video_draw_quad.h"
 
 namespace {
 const size_t kDefaultNumSharedQuadStatesToReserve = 32;
@@ -174,4 +184,59 @@ SharedQuadState* RenderPass::CreateAndAppendSharedQuadState() {
   return shared_quad_state_list.back();
 }
 
+RenderPassDrawQuad* RenderPass::CopyFromAndAppendRenderPassDrawQuad(
+    const RenderPassDrawQuad* quad,
+    const SharedQuadState* shared_quad_state,
+    RenderPass::Id render_pass_id) {
+  RenderPassDrawQuad* copy_quad =
+      CopyFromAndAppendTypedDrawQuad<RenderPassDrawQuad>(quad);
+  copy_quad->shared_quad_state = shared_quad_state;
+  copy_quad->render_pass_id = render_pass_id;
+  return copy_quad;
+}
+
+DrawQuad* RenderPass::CopyFromAndAppendDrawQuad(
+    const DrawQuad* quad,
+    const SharedQuadState* shared_quad_state) {
+  switch (quad->material) {
+    case DrawQuad::CHECKERBOARD:
+      CopyFromAndAppendTypedDrawQuad<CheckerboardDrawQuad>(quad);
+      break;
+    case DrawQuad::DEBUG_BORDER:
+      CopyFromAndAppendTypedDrawQuad<DebugBorderDrawQuad>(quad);
+      break;
+    case DrawQuad::IO_SURFACE_CONTENT:
+      CopyFromAndAppendTypedDrawQuad<IOSurfaceDrawQuad>(quad);
+      break;
+    case DrawQuad::PICTURE_CONTENT:
+      CopyFromAndAppendTypedDrawQuad<PictureDrawQuad>(quad);
+      break;
+    case DrawQuad::TEXTURE_CONTENT:
+      CopyFromAndAppendTypedDrawQuad<TextureDrawQuad>(quad);
+      break;
+    case DrawQuad::SOLID_COLOR:
+      CopyFromAndAppendTypedDrawQuad<SolidColorDrawQuad>(quad);
+      break;
+    case DrawQuad::TILED_CONTENT:
+      CopyFromAndAppendTypedDrawQuad<TileDrawQuad>(quad);
+      break;
+    case DrawQuad::STREAM_VIDEO_CONTENT:
+      CopyFromAndAppendTypedDrawQuad<StreamVideoDrawQuad>(quad);
+      break;
+    case DrawQuad::SURFACE_CONTENT:
+      CopyFromAndAppendTypedDrawQuad<SurfaceDrawQuad>(quad);
+      break;
+    case DrawQuad::YUV_VIDEO_CONTENT:
+      CopyFromAndAppendTypedDrawQuad<YUVVideoDrawQuad>(quad);
+      break;
+    // RenderPass quads need to use specific CopyFrom function.
+    case DrawQuad::RENDER_PASS:
+    case DrawQuad::INVALID:
+      LOG(FATAL) << "Invalid DrawQuad material " << quad->material;
+      break;
+  }
+  quad_list.back()->shared_quad_state = shared_quad_state;
+  return quad_list.back();
+}
+
 }  // namespace cc
diff --git a/cc/quads/render_pass.h b/cc/quads/render_pass.h
index ce5a90e..6b68f8d 100644
--- a/cc/quads/render_pass.h
+++ b/cc/quads/render_pass.h
@@ -24,6 +24,7 @@ class Value;
 namespace cc {
 
 class DrawQuad;
+class RenderPassDrawQuad;
 class CopyOutputRequest;
 class SharedQuadState;
 
@@ -96,6 +97,13 @@ class CC_EXPORT RenderPass {
     return static_cast<DrawQuadType*>(quad_list.back());
   }
 
+  RenderPassDrawQuad* CopyFromAndAppendRenderPassDrawQuad(
+      const RenderPassDrawQuad* quad,
+      const SharedQuadState* shared_quad_state,
+      RenderPass::Id render_pass_id);
+  DrawQuad* CopyFromAndAppendDrawQuad(const DrawQuad* quad,
+                                      const SharedQuadState* shared_quad_state);
+
   // Uniquely identifies the render pass in the compositor's current frame.
   Id id;
 
@@ -124,6 +132,14 @@ class CC_EXPORT RenderPass {
   RenderPass();
 
  private:
+  template <typename DrawQuadType>
+  DrawQuadType* CopyFromAndAppendTypedDrawQuad(const DrawQuad* quad) {
+    scoped_ptr<DrawQuadType> draw_quad =
+        make_scoped_ptr(new DrawQuadType(*DrawQuadType::MaterialCast(quad)));
+    quad_list.push_back(draw_quad.template PassAs<DrawQuad>());
+    return static_cast<DrawQuadType*>(quad_list.back());
+  }
+
   DISALLOW_COPY_AND_ASSIGN(RenderPass);
 };
 
diff --git a/cc/quads/render_pass_unittest.cc b/cc/quads/render_pass_unittest.cc
index 59af62d..4539533 100644
--- a/cc/quads/render_pass_unittest.cc
+++ b/cc/quads/render_pass_unittest.cc
@@ -89,11 +89,10 @@ TEST(RenderPassTest, CopyShouldBeIdenticalExceptIdAndQuads) {
                        SkXfermode::kSrcOver_Mode,
                        0);
 
-  scoped_ptr<CheckerboardDrawQuad> checkerboard_quad =
-      CheckerboardDrawQuad::Create();
+  CheckerboardDrawQuad* checkerboard_quad =
+      pass->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
   checkerboard_quad->SetNew(
       pass->shared_quad_state_list.back(), gfx::Rect(), gfx::Rect(), SkColor());
-  pass->quad_list.push_back(checkerboard_quad.PassAs<DrawQuad>());
 
   RenderPass::Id new_id(63, 4);
 
@@ -140,21 +139,19 @@ TEST(RenderPassTest, CopyAllShouldBeIdentical) {
                         SkXfermode::kSrcOver_Mode,
                         0);
 
-  scoped_ptr<CheckerboardDrawQuad> checkerboard_quad1 =
-      CheckerboardDrawQuad::Create();
+  CheckerboardDrawQuad* checkerboard_quad1 =
+      pass->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
   checkerboard_quad1->SetNew(pass->shared_quad_state_list.back(),
                              gfx::Rect(1, 1, 1, 1),
                              gfx::Rect(1, 1, 1, 1),
                              SkColor());
-  pass->quad_list.push_back(checkerboard_quad1.PassAs<DrawQuad>());
 
-  scoped_ptr<CheckerboardDrawQuad> checkerboard_quad2 =
-      CheckerboardDrawQuad::Create();
+  CheckerboardDrawQuad* checkerboard_quad2 =
+      pass->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
   checkerboard_quad2->SetNew(pass->shared_quad_state_list.back(),
                              gfx::Rect(2, 2, 2, 2),
                              gfx::Rect(2, 2, 2, 2),
                              SkColor());
-  pass->quad_list.push_back(checkerboard_quad2.PassAs<DrawQuad>());
 
   // And two quads using another shared state.
   SharedQuadState* shared_state2 = pass->CreateAndAppendSharedQuadState();
@@ -167,21 +164,19 @@ TEST(RenderPassTest, CopyAllShouldBeIdentical) {
                         SkXfermode::kSrcOver_Mode,
                         0);
 
-  scoped_ptr<CheckerboardDrawQuad> checkerboard_quad3 =
-      CheckerboardDrawQuad::Create();
+  CheckerboardDrawQuad* checkerboard_quad3 =
+      pass->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
   checkerboard_quad3->SetNew(pass->shared_quad_state_list.back(),
                              gfx::Rect(3, 3, 3, 3),
                              gfx::Rect(3, 3, 3, 3),
                              SkColor());
-  pass->quad_list.push_back(checkerboard_quad3.PassAs<DrawQuad>());
 
-  scoped_ptr<CheckerboardDrawQuad> checkerboard_quad4 =
-      CheckerboardDrawQuad::Create();
+  CheckerboardDrawQuad* checkerboard_quad4 =
+      pass->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
   checkerboard_quad4->SetNew(pass->shared_quad_state_list.back(),
                              gfx::Rect(4, 4, 4, 4),
                              gfx::Rect(4, 4, 4, 4),
                              SkColor());
-  pass->quad_list.push_back(checkerboard_quad4.PassAs<DrawQuad>());
 
   // A second render pass with a quad.
   RenderPass::Id contrib_id(4, 1);
@@ -209,13 +204,12 @@ TEST(RenderPassTest, CopyAllShouldBeIdentical) {
                                SkXfermode::kSrcOver_Mode,
                                0);
 
-  scoped_ptr<CheckerboardDrawQuad> contrib_quad =
-      CheckerboardDrawQuad::Create();
+  CheckerboardDrawQuad* contrib_quad =
+      contrib->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
   contrib_quad->SetNew(contrib->shared_quad_state_list.back(),
                        gfx::Rect(3, 3, 3, 3),
                        gfx::Rect(3, 3, 3, 3),
                        SkColor());
-  contrib->quad_list.push_back(contrib_quad.PassAs<DrawQuad>());
 
   // And a RenderPassDrawQuad for the contributing pass.
   scoped_ptr<RenderPassDrawQuad> pass_quad = RenderPassDrawQuad::Create();
@@ -229,7 +223,6 @@ TEST(RenderPassTest, CopyAllShouldBeIdentical) {
                     gfx::RectF(),  // mask_uv_rect
                     FilterOperations(),
                     FilterOperations());
-  pass->quad_list.push_back(pass_quad.PassAs<DrawQuad>());
 
   pass_list.push_back(pass.PassAs<RenderPass>());
   pass_list.push_back(contrib.PassAs<RenderPass>());
@@ -269,13 +262,12 @@ TEST(RenderPassTest, CopyAllWithCulledQuads) {
                         SkXfermode::kSrcOver_Mode,
                         0);
 
-  scoped_ptr<CheckerboardDrawQuad> checkerboard_quad1 =
-      CheckerboardDrawQuad::Create();
+  CheckerboardDrawQuad* checkerboard_quad1 =
+      pass->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
   checkerboard_quad1->SetNew(pass->shared_quad_state_list.back(),
                              gfx::Rect(1, 1, 1, 1),
                              gfx::Rect(1, 1, 1, 1),
                              SkColor());
-  pass->quad_list.push_back(checkerboard_quad1.PassAs<DrawQuad>());
 
   // A shared state with no quads, they were culled.
   SharedQuadState* shared_state2 = pass->CreateAndAppendSharedQuadState();
@@ -310,13 +302,12 @@ TEST(RenderPassTest, CopyAllWithCulledQuads) {
                         SkXfermode::kSrcOver_Mode,
                         0);
 
-  scoped_ptr<CheckerboardDrawQuad> checkerboard_quad2 =
-      CheckerboardDrawQuad::Create();
+  CheckerboardDrawQuad* checkerboard_quad2 =
+      pass->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
   checkerboard_quad2->SetNew(pass->shared_quad_state_list.back(),
                              gfx::Rect(3, 3, 3, 3),
                              gfx::Rect(3, 3, 3, 3),
                              SkColor());
-  pass->quad_list.push_back(checkerboard_quad2.PassAs<DrawQuad>());
 
   pass_list.push_back(pass.PassAs<RenderPass>());