Use RenderPass to create DrawQuad in unittests

cc/quads/render_pass.cc

 // Copyright 2011 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/quads/render_pass.h"
 
 #include "base/values.h"
 #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;
 const size_t kDefaultNumQuadsToReserve = 128;
 }
 
 namespace cc {
 
 void* RenderPass::Id::AsTracingId() const {
   COMPILE_ASSERT(sizeof(size_t) <= sizeof(void*),  // NOLINT
@@ skipping 143 matching lines @@
       TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"),
       value.get(), "cc::RenderPass", id.AsTracingId());
   return value.PassAs<base::Value>();
 }
 
 SharedQuadState* RenderPass::CreateAndAppendSharedQuadState() {
   shared_quad_state_list.push_back(make_scoped_ptr(new SharedQuadState));
   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: {
+      const CheckerboardDrawQuad* original_quad =

[danakj, 2014/07/09 17:12:09]

I think you can move this material cast into the
CopyFromAndAppendTypedDrawQuad<T> method and just pass it a DrawQuad* to keep
things more concise

+          CheckerboardDrawQuad::MaterialCast(quad);
+      CopyFromAndAppendTypedDrawQuad<CheckerboardDrawQuad>(original_quad);
+      break;
+    }
+    case DrawQuad::DEBUG_BORDER: {
+      const DebugBorderDrawQuad* original_quad =
+          DebugBorderDrawQuad::MaterialCast(quad);
+      CopyFromAndAppendTypedDrawQuad<DebugBorderDrawQuad>(original_quad);
+      break;
+    }
+    case DrawQuad::IO_SURFACE_CONTENT: {
+      const IOSurfaceDrawQuad* original_quad =
+          IOSurfaceDrawQuad::MaterialCast(quad);
+      CopyFromAndAppendTypedDrawQuad<IOSurfaceDrawQuad>(original_quad);
+      break;
+    }
+    case DrawQuad::PICTURE_CONTENT: {
+      const PictureDrawQuad* original_quad =
+          PictureDrawQuad::MaterialCast(quad);
+      CopyFromAndAppendTypedDrawQuad<PictureDrawQuad>(original_quad);
+      break;
+    }
+    case DrawQuad::TEXTURE_CONTENT: {
+      const TextureDrawQuad* original_quad =
+          TextureDrawQuad::MaterialCast(quad);
+      CopyFromAndAppendTypedDrawQuad<TextureDrawQuad>(original_quad);
+      break;
+    }
+    case DrawQuad::SOLID_COLOR: {
+      const SolidColorDrawQuad* original_quad =
+          SolidColorDrawQuad::MaterialCast(quad);
+      CopyFromAndAppendTypedDrawQuad<SolidColorDrawQuad>(original_quad);
+      break;
+    }
+    case DrawQuad::TILED_CONTENT: {
+      const TileDrawQuad* original_quad = TileDrawQuad::MaterialCast(quad);
+      CopyFromAndAppendTypedDrawQuad<TileDrawQuad>(original_quad);
+      break;
+    }
+    case DrawQuad::STREAM_VIDEO_CONTENT: {
+      const StreamVideoDrawQuad* original_quad =
+          StreamVideoDrawQuad::MaterialCast(quad);
+      CopyFromAndAppendTypedDrawQuad<StreamVideoDrawQuad>(original_quad);
+      break;
+    }
+    case DrawQuad::SURFACE_CONTENT: {
+      const SurfaceDrawQuad* original_quad =
+          SurfaceDrawQuad::MaterialCast(quad);
+      CopyFromAndAppendTypedDrawQuad<SurfaceDrawQuad>(original_quad);
+      break;
+    }
+    case DrawQuad::YUV_VIDEO_CONTENT: {
+      const YUVVideoDrawQuad* original_quad =
+          YUVVideoDrawQuad::MaterialCast(quad);
+      CopyFromAndAppendTypedDrawQuad<YUVVideoDrawQuad>(original_quad);
+      break;
+    }
+    case DrawQuad::RENDER_PASS
+        :  // RenderPass quads need to use typed copy from function.
+    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