Move Copy method from DrawQuad to RenderPass

In transition to let RenderPass take responsibility to allocate
DrawQuads, Copy method from DQ is moved to RP.

In drawquad_unittest, no RenderPass is present, thus it takes advantage
of default copy constructor.

Follow 368403003.

BUG=344962

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

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

cc/layers/delegated_renderer_layer_impl.cc

@@ -442,9 +442,9 @@ void DelegatedRendererLayerImpl::AppendRenderPassQuads(
     if (quad_visible_rect.IsEmpty())
       continue;
 
-    scoped_ptr<DrawQuad> output_quad;
     if (delegated_quad->material != DrawQuad::RENDER_PASS) {
-      output_quad = delegated_quad->Copy(output_shared_quad_state);
+      DrawQuad* output_quad = render_pass->CopyFromAndAppendDrawQuad(
+          delegated_quad, output_shared_quad_state);
       output_quad->visible_rect = quad_visible_rect;
     } else {
       RenderPass::Id delegated_contributing_render_pass_id =
@@ -461,15 +461,14 @@ void DelegatedRendererLayerImpl::AppendRenderPassQuads(
         DCHECK(output_contributing_render_pass_id !=
                append_quads_data->render_pass_id);
 
-        output_quad = RenderPassDrawQuad::MaterialCast(delegated_quad)->Copy(
-            output_shared_quad_state,
-            output_contributing_render_pass_id).PassAs<DrawQuad>();
+        RenderPassDrawQuad* output_quad =
+            render_pass->CopyFromAndAppendRenderPassDrawQuad(
+                RenderPassDrawQuad::MaterialCast(delegated_quad),
+                output_shared_quad_state,
+                output_contributing_render_pass_id);
         output_quad->visible_rect = quad_visible_rect;
       }
     }
-
-    if (output_quad)
-      render_pass->quad_list.push_back(output_quad.Pass());
   }
 }
 

cc/quads/draw_quad.cc

@@ -21,12 +21,6 @@
 #include "cc/quads/yuv_video_draw_quad.h"
 #include "ui/gfx/quad_f.h"
 
-namespace {
-template<typename T> T* TypedCopy(const cc::DrawQuad* other) {
-  return new T(*T::MaterialCast(other));
-}
-}  // namespace
-
 namespace cc {
 
 DrawQuad::DrawQuad()
@@ -62,49 +56,6 @@ void DrawQuad::SetAll(const SharedQuadState* shared_quad_state,
 DrawQuad::~DrawQuad() {
 }
 
-scoped_ptr<DrawQuad> DrawQuad::Copy(
-    const SharedQuadState* copied_shared_quad_state) const {
-  scoped_ptr<DrawQuad> copy_quad;
-  switch (material) {
-    case CHECKERBOARD:
-      copy_quad.reset(TypedCopy<CheckerboardDrawQuad>(this));
-      break;
-    case DEBUG_BORDER:
-      copy_quad.reset(TypedCopy<DebugBorderDrawQuad>(this));
-      break;
-    case IO_SURFACE_CONTENT:
-      copy_quad.reset(TypedCopy<IOSurfaceDrawQuad>(this));
-      break;
-    case PICTURE_CONTENT:
-      copy_quad.reset(TypedCopy<PictureDrawQuad>(this));
-      break;
-    case TEXTURE_CONTENT:
-      copy_quad.reset(TypedCopy<TextureDrawQuad>(this));
-      break;
-    case SOLID_COLOR:
-      copy_quad.reset(TypedCopy<SolidColorDrawQuad>(this));
-      break;
-    case TILED_CONTENT:
-      copy_quad.reset(TypedCopy<TileDrawQuad>(this));
-      break;
-    case STREAM_VIDEO_CONTENT:
-      copy_quad.reset(TypedCopy<StreamVideoDrawQuad>(this));
-      break;
-    case SURFACE_CONTENT:
-      copy_quad.reset(TypedCopy<SurfaceDrawQuad>(this));
-      break;
-    case YUV_VIDEO_CONTENT:
-      copy_quad.reset(TypedCopy<YUVVideoDrawQuad>(this));
-      break;
-    case RENDER_PASS:  // RenderPass quads have their own copy() method.
-    case INVALID:
-      LOG(FATAL) << "Invalid DrawQuad material " << material;
-      break;
-  }
-  copy_quad->shared_quad_state = copied_shared_quad_state;
-  return copy_quad.Pass();
-}
-
 scoped_ptr<base::Value> DrawQuad::AsValue() const {
   scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   value->SetInteger("material", material);

cc/quads/draw_quad.h

@@ -48,11 +48,6 @@ class CC_EXPORT DrawQuad {
 
   virtual ~DrawQuad();
 
-  // TODO(weiliangc): DrawQuad need to be allocated on RenderPass. This function
-  // need to be moved to RenderPass.
-  scoped_ptr<DrawQuad> Copy(
-      const SharedQuadState* copied_shared_quad_state) const;
-
   // TODO(danakj): Chromify or remove these SharedQuadState helpers.
   const gfx::Transform& quadTransform() const {
     return shared_quad_state->content_to_target_transform;

cc/quads/render_pass.cc

@@ -107,12 +107,13 @@ void RenderPass::CopyAll(const ScopedPtrVector<RenderPass>& in,
       if (quad->material == DrawQuad::RENDER_PASS) {
         const RenderPassDrawQuad* pass_quad =
             RenderPassDrawQuad::MaterialCast(quad);
-        copy_pass->quad_list.push_back(
-            pass_quad->Copy(copy_pass->shared_quad_state_list[sqs_i],
-                            pass_quad->render_pass_id).PassAs<DrawQuad>());
+        copy_pass->CopyFromAndAppendRenderPassDrawQuad(
+            pass_quad,
+            copy_pass->shared_quad_state_list[sqs_i],
+            pass_quad->render_pass_id);
       } else {
-        copy_pass->quad_list.push_back(source->quad_list[i]->Copy(
-            copy_pass->shared_quad_state_list[sqs_i]));
+        copy_pass->CopyFromAndAppendDrawQuad(
+            quad, copy_pass->shared_quad_state_list[sqs_i]);
       }
     }
     out->push_back(copy_pass.Pass());

cc/quads/render_pass_draw_quad.cc

@@ -24,16 +24,6 @@ scoped_ptr<RenderPassDrawQuad> RenderPassDrawQuad::Create() {
   return make_scoped_ptr(new RenderPassDrawQuad);
 }
 
-scoped_ptr<RenderPassDrawQuad> RenderPassDrawQuad::Copy(
-    const SharedQuadState* copied_shared_quad_state,
-    RenderPass::Id copied_render_pass_id) const {
-  scoped_ptr<RenderPassDrawQuad> copy_quad(
-      new RenderPassDrawQuad(*MaterialCast(this)));
-  copy_quad->shared_quad_state = copied_shared_quad_state;
-  copy_quad->render_pass_id = copied_render_pass_id;
-  return copy_quad.Pass();
-}
-
 void RenderPassDrawQuad::SetNew(
     const SharedQuadState* shared_quad_state,
     const gfx::Rect& rect,

cc/quads/render_pass_draw_quad.h

@@ -44,10 +44,6 @@ class CC_EXPORT RenderPassDrawQuad : public DrawQuad {
               const FilterOperations& filters,
               const FilterOperations& background_filters);
 
-  scoped_ptr<RenderPassDrawQuad> Copy(
-      const SharedQuadState* copied_shared_quad_state,
-      RenderPass::Id copied_render_pass_id) const;
-
   RenderPass::Id render_pass_id;
   bool is_replica;
   ResourceProvider::ResourceId mask_resource_id;

cc/surfaces/surface_aggregator.cc

@@ -248,12 +248,13 @@ void SurfaceAggregator::CopyQuadsToPass(
         RenderPass::Id remapped_pass_id =
             RemapPassId(original_pass_id, surface_id);
 
-        dest_pass->quad_list.push_back(
-            pass_quad->Copy(dest_pass->shared_quad_state_list.back(),
-                            remapped_pass_id).PassAs<DrawQuad>());
+        dest_pass->CopyFromAndAppendRenderPassDrawQuad(
+            pass_quad,
+            dest_pass->shared_quad_state_list.back(),
+            remapped_pass_id);
       } else {
-        dest_pass->quad_list.push_back(
-            quad->Copy(dest_pass->shared_quad_state_list.back()));
+        dest_pass->CopyFromAndAppendDrawQuad(
+            quad, dest_pass->shared_quad_state_list.back());
       }
     }
   }