Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(7777)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: cc/output/renderer_pixeltest.cc

Issue 368403003: Use RenderPass to create DrawQuad in unittests (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@layerrawptrDQ
Patch Set: address review comments Created 6 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « cc/output/overlay_unittest.cc ('k') | cc/output/software_renderer_unittest.cc » ('j') | cc/quads/render_pass.cc » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: cc/output/renderer_pixeltest.cc
diff --git a/cc/output/renderer_pixeltest.cc b/cc/output/renderer_pixeltest.cc
index 2377043d45a4deba2fb650805f40eb2c9ec2376a..074c051620f255987763859dec68927be6563719 100644
--- a/cc/output/renderer_pixeltest.cc
+++ b/cc/output/renderer_pixeltest.cc
@@ -49,9 +49,9 @@ scoped_ptr<RenderPass> CreateTestRenderPass(
}
SharedQuadState* CreateTestSharedQuadState(
- RenderPass* render_pass,
gfx::Transform content_to_target_transform,
- const gfx::Rect& rect) {
+ const gfx::Rect& rect,
+ RenderPass* render_pass) {
const gfx::Size content_bounds = rect.size();
const gfx::Rect visible_content_rect = rect;
const gfx::Rect clip_rect = rect;
@@ -72,10 +72,10 @@ SharedQuadState* CreateTestSharedQuadState(
}
SharedQuadState* CreateTestSharedQuadStateClipped(
- RenderPass* render_pass,
gfx::Transform content_to_target_transform,
const gfx::Rect& rect,
- const gfx::Rect& clip_rect) {
+ const gfx::Rect& clip_rect,
+ RenderPass* render_pass) {
const gfx::Size content_bounds = rect.size();
const gfx::Rect visible_content_rect = clip_rect;
const bool is_clipped = true;
@@ -94,11 +94,12 @@ SharedQuadState* CreateTestSharedQuadStateClipped(
return shared_state;
}
-scoped_ptr<DrawQuad> CreateTestRenderPassDrawQuad(
- SharedQuadState* shared_state,
- const gfx::Rect& rect,
- RenderPass::Id pass_id) {
- scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
+void CreateTestRenderPassDrawQuad(const SharedQuadState* shared_state,
+ const gfx::Rect& rect,
+ RenderPass::Id pass_id,
+ RenderPass* render_pass) {
+ RenderPassDrawQuad* quad =
+ render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
quad->SetNew(shared_state,
rect,
rect,
@@ -109,17 +110,15 @@ scoped_ptr<DrawQuad> CreateTestRenderPassDrawQuad(
gfx::RectF(1.f, 1.f), // mask_uv_rect
FilterOperations(), // foreground filters
FilterOperations()); // background filters
-
- return quad.PassAs<DrawQuad>();
}
-scoped_ptr<TextureDrawQuad> CreateTestTextureDrawQuad(
- const gfx::Rect& rect,
- SkColor texel_color,
- SkColor background_color,
- bool premultiplied_alpha,
- SharedQuadState* shared_state,
- ResourceProvider* resource_provider) {
+void CreateTestTextureDrawQuad(const gfx::Rect& rect,
+ SkColor texel_color,
+ SkColor background_color,
+ bool premultiplied_alpha,
+ const SharedQuadState* shared_state,
+ ResourceProvider* resource_provider,
+ RenderPass* render_pass) {
SkPMColor pixel_color = premultiplied_alpha ?
SkPreMultiplyColor(texel_color) :
SkPackARGB32NoCheck(SkColorGetA(texel_color),
@@ -142,7 +141,8 @@ scoped_ptr<TextureDrawQuad> CreateTestTextureDrawQuad(
float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f};
- scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
+ TextureDrawQuad* quad =
+ render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
quad->SetNew(shared_state,
rect,
gfx::Rect(),
@@ -154,7 +154,6 @@ scoped_ptr<TextureDrawQuad> CreateTestTextureDrawQuad(
background_color,
vertex_opacity,
false); // flipped
- return quad.Pass();
}
typedef ::testing::Types<GLRenderer,
@@ -213,13 +212,12 @@ TYPED_TEST(RendererPixelTest, SimpleGreenRect) {
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
SharedQuadState* shared_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
+ CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
- scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* color_quad =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
color_quad->SetNew(shared_state, rect, rect, SK_ColorGREEN, false);
- pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
-
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -238,22 +236,21 @@ TYPED_TEST(RendererPixelTest, SimpleGreenRect_NonRootRenderPass) {
CreateTestRenderPass(child_id, small_rect, gfx::Transform());
SharedQuadState* child_shared_state =
- CreateTestSharedQuadState(child_pass.get(), gfx::Transform(), small_rect);
+ CreateTestSharedQuadState(gfx::Transform(), small_rect, child_pass.get());
- scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* color_quad =
+ child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
color_quad->SetNew(child_shared_state, rect, rect, SK_ColorGREEN, false);
- child_pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
RenderPass::Id root_id(1, 1);
scoped_ptr<RenderPass> root_pass =
CreateTestRenderPass(root_id, rect, gfx::Transform());
SharedQuadState* root_shared_state =
- CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), rect);
+ CreateTestSharedQuadState(gfx::Transform(), rect, root_pass.get());
- scoped_ptr<DrawQuad> render_pass_quad =
- CreateTestRenderPassDrawQuad(root_shared_state, small_rect, child_id);
- root_pass->quad_list.push_back(render_pass_quad.PassAs<DrawQuad>());
+ CreateTestRenderPassDrawQuad(
+ root_shared_state, small_rect, child_id, root_pass.get());
RenderPass* child_pass_ptr = child_pass.get();
@@ -275,20 +272,19 @@ TYPED_TEST(RendererPixelTest, PremultipliedTextureWithoutBackground) {
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
SharedQuadState* shared_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
+ CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
- scoped_ptr<TextureDrawQuad> texture_quad =
- CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_),
- SkColorSetARGB(128, 0, 255, 0), // Texel color.
- SK_ColorTRANSPARENT, // Background color.
- true, // Premultiplied alpha.
- shared_state,
- this->resource_provider_.get());
- pass->quad_list.push_back(texture_quad.PassAs<DrawQuad>());
+ CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_),
+ SkColorSetARGB(128, 0, 255, 0), // Texel color.
+ SK_ColorTRANSPARENT, // Background color.
+ true, // Premultiplied alpha.
+ shared_state,
+ this->resource_provider_.get(),
+ pass.get());
- scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* color_quad =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false);
- pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -306,23 +302,22 @@ TYPED_TEST(RendererPixelTest, PremultipliedTextureWithBackground) {
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
SharedQuadState* texture_quad_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
+ CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
texture_quad_state->opacity = 0.8f;
- scoped_ptr<TextureDrawQuad> texture_quad = CreateTestTextureDrawQuad(
- gfx::Rect(this->device_viewport_size_),
- SkColorSetARGB(204, 120, 255, 120), // Texel color.
- SK_ColorGREEN, // Background color.
- true, // Premultiplied alpha.
- texture_quad_state,
- this->resource_provider_.get());
- pass->quad_list.push_back(texture_quad.PassAs<DrawQuad>());
+ CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_),
+ SkColorSetARGB(204, 120, 255, 120), // Texel color.
+ SK_ColorGREEN, // Background color.
+ true, // Premultiplied alpha.
+ texture_quad_state,
+ this->resource_provider_.get(),
+ pass.get());
SharedQuadState* color_quad_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
- scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
+ CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
+ SolidColorDrawQuad* color_quad =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
color_quad->SetNew(color_quad_state, rect, rect, SK_ColorWHITE, false);
- pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -341,20 +336,19 @@ TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithoutBackground) {
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
SharedQuadState* shared_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
+ CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
- scoped_ptr<TextureDrawQuad> texture_quad =
- CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_),
- SkColorSetARGB(128, 0, 255, 0), // Texel color.
- SK_ColorTRANSPARENT, // Background color.
- false, // Premultiplied alpha.
- shared_state,
- this->resource_provider_.get());
- pass->quad_list.push_back(texture_quad.PassAs<DrawQuad>());
+ CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_),
+ SkColorSetARGB(128, 0, 255, 0), // Texel color.
+ SK_ColorTRANSPARENT, // Background color.
+ false, // Premultiplied alpha.
+ shared_state,
+ this->resource_provider_.get(),
+ pass.get());
- scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* color_quad =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false);
- pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -373,23 +367,22 @@ TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithBackground) {
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
SharedQuadState* texture_quad_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
+ CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
texture_quad_state->opacity = 0.8f;
- scoped_ptr<TextureDrawQuad> texture_quad = CreateTestTextureDrawQuad(
- gfx::Rect(this->device_viewport_size_),
- SkColorSetARGB(204, 120, 255, 120), // Texel color.
- SK_ColorGREEN, // Background color.
- false, // Premultiplied alpha.
- texture_quad_state,
- this->resource_provider_.get());
- pass->quad_list.push_back(texture_quad.PassAs<DrawQuad>());
+ CreateTestTextureDrawQuad(gfx::Rect(this->device_viewport_size_),
+ SkColorSetARGB(204, 120, 255, 120), // Texel color.
+ SK_ColorGREEN, // Background color.
+ false, // Premultiplied alpha.
+ texture_quad_state,
+ this->resource_provider_.get(),
+ pass.get());
SharedQuadState* color_quad_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
- scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
+ CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
+ SolidColorDrawQuad* color_quad =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
color_quad->SetNew(color_quad_state, rect, rect, SK_ColorWHITE, false);
- pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -402,11 +395,11 @@ TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithBackground) {
class VideoGLRendererPixelTest : public GLRendererPixelTest {
protected:
- scoped_ptr<YUVVideoDrawQuad> CreateTestYUVVideoDrawQuad_Striped(
- SharedQuadState* shared_state,
- media::VideoFrame::Format format,
- bool is_transparent,
- const gfx::RectF& tex_coord_rect) {
+ void CreateTestYUVVideoDrawQuad_Striped(const SharedQuadState* shared_state,
+ media::VideoFrame::Format format,
+ bool is_transparent,
+ const gfx::RectF& tex_coord_rect,
+ RenderPass* render_pass) {
const gfx::Rect rect(this->device_viewport_size_);
scoped_refptr<media::VideoFrame> video_frame =
@@ -437,18 +430,18 @@ class VideoGLRendererPixelTest : public GLRendererPixelTest {
v_row[j] = (v_value += 5);
}
}
- return CreateTestYUVVideoDrawQuad_FromVideoFrame(
- shared_state, video_frame, is_transparent, tex_coord_rect);
+ CreateTestYUVVideoDrawQuad_FromVideoFrame(
+ shared_state, video_frame, is_transparent, tex_coord_rect, render_pass);
}
- scoped_ptr<YUVVideoDrawQuad> CreateTestYUVVideoDrawQuad_Solid(
- SharedQuadState* shared_state,
- media::VideoFrame::Format format,
- bool is_transparent,
- const gfx::RectF& tex_coord_rect,
- uint8 y,
- uint8 u,
- uint8 v) {
+ void CreateTestYUVVideoDrawQuad_Solid(const SharedQuadState* shared_state,
+ media::VideoFrame::Format format,
+ bool is_transparent,
+ const gfx::RectF& tex_coord_rect,
+ uint8 y,
+ uint8 u,
+ uint8 v,
+ RenderPass* render_pass) {
const gfx::Rect rect(this->device_viewport_size_);
scoped_refptr<media::VideoFrame> video_frame =
@@ -470,15 +463,16 @@ class VideoGLRendererPixelTest : public GLRendererPixelTest {
video_frame->stride(media::VideoFrame::kVPlane) *
video_frame->rows(media::VideoFrame::kVPlane));
- return CreateTestYUVVideoDrawQuad_FromVideoFrame(
- shared_state, video_frame, is_transparent, tex_coord_rect);
+ CreateTestYUVVideoDrawQuad_FromVideoFrame(
+ shared_state, video_frame, is_transparent, tex_coord_rect, render_pass);
}
- scoped_ptr<YUVVideoDrawQuad> CreateTestYUVVideoDrawQuad_FromVideoFrame(
- SharedQuadState* shared_state,
+ void CreateTestYUVVideoDrawQuad_FromVideoFrame(
+ const SharedQuadState* shared_state,
scoped_refptr<media::VideoFrame> video_frame,
bool is_transparent,
- const gfx::RectF& tex_coord_rect) {
+ const gfx::RectF& tex_coord_rect,
+ RenderPass* render_pass) {
const bool with_alpha = (video_frame->format() == media::VideoFrame::YV12A);
const YUVVideoDrawQuad::ColorSpace color_space =
(video_frame->format() == media::VideoFrame::YV12J
@@ -526,7 +520,8 @@ class VideoGLRendererPixelTest : public GLRendererPixelTest {
resources.release_callbacks[media::VideoFrame::kAPlane]));
}
- scoped_ptr<YUVVideoDrawQuad> yuv_quad = YUVVideoDrawQuad::Create();
+ YUVVideoDrawQuad* yuv_quad =
+ render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>();
yuv_quad->SetNew(shared_state,
rect,
opaque_rect,
@@ -537,7 +532,6 @@ class VideoGLRendererPixelTest : public GLRendererPixelTest {
v_resource,
a_resource,
color_space);
- return yuv_quad.Pass();
}
virtual void SetUp() OVERRIDE {
@@ -557,15 +551,13 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVRect) {
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
SharedQuadState* shared_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
+ CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
- scoped_ptr<YUVVideoDrawQuad> yuv_quad =
- CreateTestYUVVideoDrawQuad_Striped(shared_state,
- media::VideoFrame::YV12,
- false,
- gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f));
-
- pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>());
+ CreateTestYUVVideoDrawQuad_Striped(shared_state,
+ media::VideoFrame::YV12,
+ false,
+ gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
+ pass.get());
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -583,16 +575,14 @@ TEST_F(VideoGLRendererPixelTest, OffsetYUVRect) {
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
SharedQuadState* shared_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
+ CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
// Intentionally sets frame format to I420 for testing coverage.
- scoped_ptr<YUVVideoDrawQuad> yuv_quad = CreateTestYUVVideoDrawQuad_Striped(
- shared_state,
- media::VideoFrame::I420,
- false,
- gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f));
-
- pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>());
+ CreateTestYUVVideoDrawQuad_Striped(shared_state,
+ media::VideoFrame::I420,
+ false,
+ gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f),
+ pass.get());
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -610,19 +600,17 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVRectBlack) {
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
SharedQuadState* shared_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
+ CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
// In MPEG color range YUV values of (15,128,128) should produce black.
- scoped_ptr<YUVVideoDrawQuad> yuv_quad =
- CreateTestYUVVideoDrawQuad_Solid(shared_state,
- media::VideoFrame::YV12,
- false,
- gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
- 15,
- 128,
- 128);
-
- pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>());
+ CreateTestYUVVideoDrawQuad_Solid(shared_state,
+ media::VideoFrame::YV12,
+ false,
+ gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
+ 15,
+ 128,
+ 128,
+ pass.get());
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -641,19 +629,17 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVJRect) {
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
SharedQuadState* shared_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
+ CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
// YUV of (149,43,21) should be green (0,255,0) in RGB.
- scoped_ptr<YUVVideoDrawQuad> yuv_quad =
- CreateTestYUVVideoDrawQuad_Solid(shared_state,
- media::VideoFrame::YV12J,
- false,
- gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
- 149,
- 43,
- 21);
-
- pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>());
+ CreateTestYUVVideoDrawQuad_Solid(shared_state,
+ media::VideoFrame::YV12J,
+ false,
+ gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
+ 149,
+ 43,
+ 21,
+ pass.get());
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -670,19 +656,17 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVJRectGrey) {
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
SharedQuadState* shared_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
+ CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
// Dark grey in JPEG color range (in MPEG, this is black).
- scoped_ptr<YUVVideoDrawQuad> yuv_quad =
- CreateTestYUVVideoDrawQuad_Solid(shared_state,
- media::VideoFrame::YV12J,
- false,
- gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
- 15,
- 128,
- 128);
-
- pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>());
+ CreateTestYUVVideoDrawQuad_Solid(shared_state,
+ media::VideoFrame::YV12J,
+ false,
+ gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
+ 15,
+ 128,
+ 128,
+ pass.get());
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -700,21 +684,18 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) {
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
SharedQuadState* shared_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
+ CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
- scoped_ptr<YUVVideoDrawQuad> yuv_quad =
- CreateTestYUVVideoDrawQuad_Striped(shared_state,
- media::VideoFrame::YV12A,
- false,
- gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f));
+ CreateTestYUVVideoDrawQuad_Striped(shared_state,
+ media::VideoFrame::YV12A,
+ false,
+ gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
+ pass.get());
- pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>());
-
- scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* color_quad =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false);
- pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
-
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -731,21 +712,18 @@ TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) {
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
SharedQuadState* shared_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
+ CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
- scoped_ptr<YUVVideoDrawQuad> yuv_quad =
- CreateTestYUVVideoDrawQuad_Striped(shared_state,
- media::VideoFrame::YV12A,
- true,
- gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f));
+ CreateTestYUVVideoDrawQuad_Striped(shared_state,
+ media::VideoFrame::YV12A,
+ true,
+ gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
+ pass.get());
- pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>());
-
- scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* color_quad =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
color_quad->SetNew(shared_state, rect, rect, SK_ColorBLACK, false);
- pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
-
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -770,35 +748,34 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) {
gfx::Transform content_to_target_transform;
SharedQuadState* shared_state = CreateTestSharedQuadState(
- child_pass.get(), content_to_target_transform, viewport_rect);
+ content_to_target_transform, viewport_rect, child_pass.get());
shared_state->opacity = 0.5f;
gfx::Rect blue_rect(0,
0,
this->device_viewport_size_.width(),
this->device_viewport_size_.height() / 2);
- scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* blue =
+ child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
gfx::Rect yellow_rect(0,
this->device_viewport_size_.height() / 2,
this->device_viewport_size_.width(),
this->device_viewport_size_.height() / 2);
- scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* yellow =
+ child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);
SharedQuadState* blank_state = CreateTestSharedQuadState(
- child_pass.get(), content_to_target_transform, viewport_rect);
+ content_to_target_transform, viewport_rect, child_pass.get());
- scoped_ptr<SolidColorDrawQuad> white = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* white =
+ child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
white->SetNew(
blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false);
- child_pass->quad_list.push_back(blue.PassAs<DrawQuad>());
- child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
- child_pass->quad_list.push_back(white.PassAs<DrawQuad>());
-
SharedQuadState* pass_shared_state =
- CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), pass_rect);
+ CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
SkScalar matrix[20];
float amount = 0.5f;
@@ -823,8 +800,8 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) {
FilterOperations filters;
filters.Append(FilterOperation::CreateReferenceFilter(filter));
- scoped_ptr<RenderPassDrawQuad> render_pass_quad =
- RenderPassDrawQuad::Create();
+ RenderPassDrawQuad* render_pass_quad =
+ root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
render_pass_quad->SetNew(pass_shared_state,
pass_rect,
pass_rect,
@@ -836,8 +813,6 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) {
filters,
FilterOperations());
- root_pass->quad_list.push_back(render_pass_quad.PassAs<DrawQuad>());
-
RenderPassList pass_list;
pass_list.push_back(child_pass.Pass());
pass_list.push_back(root_pass.Pass());
@@ -865,41 +840,40 @@ TYPED_TEST(RendererPixelTest, FastPassSaturateFilter) {
gfx::Transform content_to_target_transform;
SharedQuadState* shared_state = CreateTestSharedQuadState(
- child_pass.get(), content_to_target_transform, viewport_rect);
+ content_to_target_transform, viewport_rect, child_pass.get());
shared_state->opacity = 0.5f;
gfx::Rect blue_rect(0,
0,
this->device_viewport_size_.width(),
this->device_viewport_size_.height() / 2);
- scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* blue =
+ child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
gfx::Rect yellow_rect(0,
this->device_viewport_size_.height() / 2,
this->device_viewport_size_.width(),
this->device_viewport_size_.height() / 2);
- scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* yellow =
+ child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);
SharedQuadState* blank_state = CreateTestSharedQuadState(
- child_pass.get(), content_to_target_transform, viewport_rect);
+ content_to_target_transform, viewport_rect, child_pass.get());
- scoped_ptr<SolidColorDrawQuad> white = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* white =
+ child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
white->SetNew(
blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false);
- child_pass->quad_list.push_back(blue.PassAs<DrawQuad>());
- child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
- child_pass->quad_list.push_back(white.PassAs<DrawQuad>());
-
SharedQuadState* pass_shared_state =
- CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), pass_rect);
+ CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
FilterOperations filters;
filters.Append(FilterOperation::CreateSaturateFilter(0.5f));
- scoped_ptr<RenderPassDrawQuad> render_pass_quad =
- RenderPassDrawQuad::Create();
+ RenderPassDrawQuad* render_pass_quad =
+ root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
render_pass_quad->SetNew(pass_shared_state,
pass_rect,
pass_rect,
@@ -911,8 +885,6 @@ TYPED_TEST(RendererPixelTest, FastPassSaturateFilter) {
filters,
FilterOperations());
- root_pass->quad_list.push_back(render_pass_quad.PassAs<DrawQuad>());
-
RenderPassList pass_list;
pass_list.push_back(child_pass.Pass());
pass_list.push_back(root_pass.Pass());
@@ -938,42 +910,41 @@ TYPED_TEST(RendererPixelTest, FastPassFilterChain) {
gfx::Transform content_to_target_transform;
SharedQuadState* shared_state = CreateTestSharedQuadState(
- child_pass.get(), content_to_target_transform, viewport_rect);
+ content_to_target_transform, viewport_rect, child_pass.get());
shared_state->opacity = 0.5f;
gfx::Rect blue_rect(0,
0,
this->device_viewport_size_.width(),
this->device_viewport_size_.height() / 2);
- scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* blue =
+ child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
gfx::Rect yellow_rect(0,
this->device_viewport_size_.height() / 2,
this->device_viewport_size_.width(),
this->device_viewport_size_.height() / 2);
- scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* yellow =
+ child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);
SharedQuadState* blank_state = CreateTestSharedQuadState(
- child_pass.get(), content_to_target_transform, viewport_rect);
+ content_to_target_transform, viewport_rect, child_pass.get());
- scoped_ptr<SolidColorDrawQuad> white = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* white =
+ child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
white->SetNew(
blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false);
- child_pass->quad_list.push_back(blue.PassAs<DrawQuad>());
- child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
- child_pass->quad_list.push_back(white.PassAs<DrawQuad>());
-
SharedQuadState* pass_shared_state =
- CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), pass_rect);
+ CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
FilterOperations filters;
filters.Append(FilterOperation::CreateGrayscaleFilter(1.f));
filters.Append(FilterOperation::CreateBrightnessFilter(0.5f));
- scoped_ptr<RenderPassDrawQuad> render_pass_quad =
- RenderPassDrawQuad::Create();
+ RenderPassDrawQuad* render_pass_quad =
+ root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
render_pass_quad->SetNew(pass_shared_state,
pass_rect,
pass_rect,
@@ -985,8 +956,6 @@ TYPED_TEST(RendererPixelTest, FastPassFilterChain) {
filters,
FilterOperations());
- root_pass->quad_list.push_back(render_pass_quad.PassAs<DrawQuad>());
-
RenderPassList pass_list;
pass_list.push_back(child_pass.Pass());
pass_list.push_back(root_pass.Pass());
@@ -1012,35 +981,34 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) {
gfx::Transform content_to_target_transform;
SharedQuadState* shared_state = CreateTestSharedQuadState(
- child_pass.get(), content_to_target_transform, viewport_rect);
+ content_to_target_transform, viewport_rect, child_pass.get());
shared_state->opacity = 0.5f;
gfx::Rect blue_rect(0,
0,
this->device_viewport_size_.width(),
this->device_viewport_size_.height() / 2);
- scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* blue =
+ child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
gfx::Rect yellow_rect(0,
this->device_viewport_size_.height() / 2,
this->device_viewport_size_.width(),
this->device_viewport_size_.height() / 2);
- scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* yellow =
+ child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);
SharedQuadState* blank_state = CreateTestSharedQuadState(
- child_pass.get(), content_to_target_transform, viewport_rect);
+ content_to_target_transform, viewport_rect, child_pass.get());
- scoped_ptr<SolidColorDrawQuad> white = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* white =
+ child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
white->SetNew(
blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false);
- child_pass->quad_list.push_back(blue.PassAs<DrawQuad>());
- child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
- child_pass->quad_list.push_back(white.PassAs<DrawQuad>());
-
SharedQuadState* pass_shared_state =
- CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), pass_rect);
+ CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
SkScalar matrix[20];
float amount = 0.5f;
@@ -1068,8 +1036,8 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) {
FilterOperations filters;
filters.Append(FilterOperation::CreateReferenceFilter(filter));
- scoped_ptr<RenderPassDrawQuad> render_pass_quad =
- RenderPassDrawQuad::Create();
+ RenderPassDrawQuad* render_pass_quad =
+ root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
render_pass_quad->SetNew(pass_shared_state,
pass_rect,
pass_rect,
@@ -1081,7 +1049,6 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) {
filters,
FilterOperations());
- root_pass->quad_list.push_back(render_pass_quad.PassAs<DrawQuad>());
RenderPassList pass_list;
pass_list.push_back(child_pass.Pass());
@@ -1110,28 +1077,27 @@ TYPED_TEST(RendererPixelTest, EnlargedRenderPassTexture) {
gfx::Transform content_to_target_transform;
SharedQuadState* shared_state = CreateTestSharedQuadState(
- child_pass.get(), content_to_target_transform, viewport_rect);
+ content_to_target_transform, viewport_rect, child_pass.get());
gfx::Rect blue_rect(0,
0,
this->device_viewport_size_.width(),
this->device_viewport_size_.height() / 2);
- scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* blue =
+ child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
gfx::Rect yellow_rect(0,
this->device_viewport_size_.height() / 2,
this->device_viewport_size_.width(),
this->device_viewport_size_.height() / 2);
- scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* yellow =
+ child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);
- child_pass->quad_list.push_back(blue.PassAs<DrawQuad>());
- child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
-
SharedQuadState* pass_shared_state =
- CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), pass_rect);
- root_pass->quad_list.push_back(CreateTestRenderPassDrawQuad(
- pass_shared_state, pass_rect, child_pass_id));
+ CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
+ CreateTestRenderPassDrawQuad(
+ pass_shared_state, pass_rect, child_pass_id, root_pass.get());
RenderPassList pass_list;
pass_list.push_back(child_pass.Pass());
@@ -1160,41 +1126,40 @@ TYPED_TEST(RendererPixelTest, EnlargedRenderPassTextureWithAntiAliasing) {
gfx::Transform content_to_target_transform;
SharedQuadState* shared_state = CreateTestSharedQuadState(
- child_pass.get(), content_to_target_transform, viewport_rect);
+ content_to_target_transform, viewport_rect, child_pass.get());
gfx::Rect blue_rect(0,
0,
this->device_viewport_size_.width(),
this->device_viewport_size_.height() / 2);
- scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* blue =
+ child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
gfx::Rect yellow_rect(0,
this->device_viewport_size_.height() / 2,
this->device_viewport_size_.width(),
this->device_viewport_size_.height() / 2);
- scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* yellow =
+ child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false);
- child_pass->quad_list.push_back(blue.PassAs<DrawQuad>());
- child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
-
gfx::Transform aa_transform;
aa_transform.Translate(0.5, 0.0);
SharedQuadState* pass_shared_state =
- CreateTestSharedQuadState(root_pass.get(), aa_transform, pass_rect);
- root_pass->quad_list.push_back(CreateTestRenderPassDrawQuad(
- pass_shared_state, pass_rect, child_pass_id));
+ CreateTestSharedQuadState(aa_transform, pass_rect, root_pass.get());
+ CreateTestRenderPassDrawQuad(
+ pass_shared_state, pass_rect, child_pass_id, root_pass.get());
SharedQuadState* root_shared_state = CreateTestSharedQuadState(
- root_pass.get(), gfx::Transform(), viewport_rect);
- scoped_ptr<SolidColorDrawQuad> background = SolidColorDrawQuad::Create();
+ gfx::Transform(), viewport_rect, root_pass.get());
+ SolidColorDrawQuad* background =
+ root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
background->SetNew(root_shared_state,
gfx::Rect(this->device_viewport_size_),
gfx::Rect(this->device_viewport_size_),
SK_ColorWHITE,
false);
- root_pass->quad_list.push_back(background.PassAs<DrawQuad>());
RenderPassList pass_list;
pass_list.push_back(child_pass.Pass());
@@ -1217,21 +1182,21 @@ TYPED_TEST(RendererPixelTest, RenderPassAndMaskWithPartialQuad) {
scoped_ptr<RenderPass> root_pass =
CreateTestRootRenderPass(root_pass_id, viewport_rect);
SharedQuadState* root_pass_shared_state = CreateTestSharedQuadState(
- root_pass.get(), gfx::Transform(), viewport_rect);
+ gfx::Transform(), viewport_rect, root_pass.get());
RenderPass::Id child_pass_id(2, 2);
gfx::Transform transform_to_root;
scoped_ptr<RenderPass> child_pass =
CreateTestRenderPass(child_pass_id, viewport_rect, transform_to_root);
SharedQuadState* child_pass_shared_state = CreateTestSharedQuadState(
- child_pass.get(), gfx::Transform(), viewport_rect);
+ gfx::Transform(), viewport_rect, child_pass.get());
// The child render pass is just a green box.
static const SkColor kCSSGreen = 0xff008000;
- scoped_ptr<SolidColorDrawQuad> green = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* green =
+ child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
green->SetNew(
child_pass_shared_state, viewport_rect, viewport_rect, kCSSGreen, false);
- child_pass->quad_list.push_back(green.PassAs<DrawQuad>());
// Make a mask.
gfx::Rect mask_rect = viewport_rect;
@@ -1279,7 +1244,8 @@ TYPED_TEST(RendererPixelTest, RenderPassAndMaskWithPartialQuad) {
EXPECT_TRUE(child_pass->output_rect.Contains(sub_rect));
// Set up a mask on the RenderPassDrawQuad.
- scoped_ptr<RenderPassDrawQuad> mask_quad = RenderPassDrawQuad::Create();
+ RenderPassDrawQuad* mask_quad =
+ root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
mask_quad->SetNew(root_pass_shared_state,
sub_rect,
sub_rect,
@@ -1290,16 +1256,15 @@ TYPED_TEST(RendererPixelTest, RenderPassAndMaskWithPartialQuad) {
gfx::RectF(1.f, 1.f), // mask_uv_rect
FilterOperations(), // foreground filters
FilterOperations()); // background filters
- root_pass->quad_list.push_back(mask_quad.PassAs<DrawQuad>());
// White background behind the masked render pass.
- scoped_ptr<SolidColorDrawQuad> white = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* white =
+ root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
white->SetNew(root_pass_shared_state,
viewport_rect,
viewport_rect,
SK_ColorWHITE,
false);
- root_pass->quad_list.push_back(white.PassAs<DrawQuad>());
RenderPassList pass_list;
pass_list.push_back(child_pass.Pass());
@@ -1335,25 +1300,25 @@ class RendererPixelTestWithBackgroundFilter
// A non-visible quad in the filtering render pass.
{
SharedQuadState* shared_state =
- CreateTestSharedQuadState(filter_pass.get(),
- identity_content_to_target_transform,
- filter_pass_content_rect_);
- scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
+ CreateTestSharedQuadState(identity_content_to_target_transform,
+ filter_pass_content_rect_,
+ filter_pass.get());
+ SolidColorDrawQuad* color_quad =
+ filter_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
color_quad->SetNew(shared_state,
filter_pass_content_rect_,
filter_pass_content_rect_,
SK_ColorTRANSPARENT,
false);
- filter_pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
}
{
SharedQuadState* shared_state =
- CreateTestSharedQuadState(filter_pass.get(),
- filter_pass_to_target_transform_,
- filter_pass_content_rect_);
- scoped_ptr<RenderPassDrawQuad> filter_pass_quad =
- RenderPassDrawQuad::Create();
+ CreateTestSharedQuadState(filter_pass_to_target_transform_,
+ filter_pass_content_rect_,
+ filter_pass.get());
+ RenderPassDrawQuad* filter_pass_quad =
+ root_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
filter_pass_quad->SetNew(
shared_state,
filter_pass_content_rect_,
@@ -1365,7 +1330,6 @@ class RendererPixelTestWithBackgroundFilter
gfx::RectF(), // mask_uv_rect
FilterOperations(), // filters
this->background_filters_);
- root_pass->quad_list.push_back(filter_pass_quad.PassAs<DrawQuad>());
}
const int kColumnWidth = device_viewport_rect.width() / 3;
@@ -1373,48 +1337,47 @@ class RendererPixelTestWithBackgroundFilter
gfx::Rect left_rect = gfx::Rect(0, 0, kColumnWidth, 20);
for (int i = 0; left_rect.y() < device_viewport_rect.height(); ++i) {
SharedQuadState* shared_state = CreateTestSharedQuadState(
- root_pass.get(), identity_content_to_target_transform, left_rect);
- scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
+ identity_content_to_target_transform, left_rect, root_pass.get());
+ SolidColorDrawQuad* color_quad =
+ root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
color_quad->SetNew(
shared_state, left_rect, left_rect, SK_ColorGREEN, false);
- root_pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
left_rect += gfx::Vector2d(0, left_rect.height() + 1);
}
gfx::Rect middle_rect = gfx::Rect(kColumnWidth+1, 0, kColumnWidth, 20);
for (int i = 0; middle_rect.y() < device_viewport_rect.height(); ++i) {
SharedQuadState* shared_state = CreateTestSharedQuadState(
- root_pass.get(), identity_content_to_target_transform, middle_rect);
- scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
+ identity_content_to_target_transform, middle_rect, root_pass.get());
+ SolidColorDrawQuad* color_quad =
+ root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
color_quad->SetNew(
shared_state, middle_rect, middle_rect, SK_ColorRED, false);
- root_pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
middle_rect += gfx::Vector2d(0, middle_rect.height() + 1);
}
gfx::Rect right_rect = gfx::Rect((kColumnWidth+1)*2, 0, kColumnWidth, 20);
for (int i = 0; right_rect.y() < device_viewport_rect.height(); ++i) {
SharedQuadState* shared_state = CreateTestSharedQuadState(
- root_pass.get(), identity_content_to_target_transform, right_rect);
- scoped_ptr<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
+ identity_content_to_target_transform, right_rect, root_pass.get());
+ SolidColorDrawQuad* color_quad =
+ root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
color_quad->SetNew(
shared_state, right_rect, right_rect, SK_ColorBLUE, false);
- root_pass->quad_list.push_back(color_quad.PassAs<DrawQuad>());
right_rect += gfx::Vector2d(0, right_rect.height() + 1);
}
SharedQuadState* shared_state =
- CreateTestSharedQuadState(root_pass.get(),
- identity_content_to_target_transform,
- device_viewport_rect);
- scoped_ptr<SolidColorDrawQuad> background_quad =
- SolidColorDrawQuad::Create();
+ CreateTestSharedQuadState(identity_content_to_target_transform,
+ device_viewport_rect,
+ root_pass.get());
+ SolidColorDrawQuad* background_quad =
+ root_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
background_quad->SetNew(shared_state,
device_viewport_rect,
device_viewport_rect,
SK_ColorWHITE,
false);
- root_pass->quad_list.push_back(background_quad.PassAs<DrawQuad>());
pass_list_.push_back(filter_pass.Pass());
pass_list_.push_back(root_pass.Pass());
@@ -1492,10 +1455,10 @@ TEST_F(ExternalStencilPixelTest, StencilTestEnabled) {
RenderPass::Id id(1, 1);
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
SharedQuadState* blue_shared_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
- scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create();
+ CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
+ SolidColorDrawQuad* blue =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false);
- pass->quad_list.push_back(blue.PassAs<DrawQuad>());
pass->has_transparent_background = false;
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -1515,10 +1478,10 @@ TEST_F(ExternalStencilPixelTest, StencilTestDisabled) {
RenderPass::Id id(1, 1);
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
SharedQuadState* green_shared_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
- scoped_ptr<SolidColorDrawQuad> green = SolidColorDrawQuad::Create();
+ CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
+ SolidColorDrawQuad* green =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
green->SetNew(green_shared_state, rect, rect, SK_ColorGREEN, false);
- pass->quad_list.push_back(green.PassAs<DrawQuad>());
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -1549,20 +1512,20 @@ TEST_F(ExternalStencilPixelTest, RenderSurfacesIgnoreStencil) {
gfx::Transform content_to_target_transform;
SharedQuadState* shared_state = CreateTestSharedQuadState(
- child_pass.get(), content_to_target_transform, viewport_rect);
+ content_to_target_transform, viewport_rect, child_pass.get());
gfx::Rect blue_rect(0,
0,
this->device_viewport_size_.width(),
this->device_viewport_size_.height());
- scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* blue =
+ child_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false);
- child_pass->quad_list.push_back(blue.PassAs<DrawQuad>());
SharedQuadState* pass_shared_state =
- CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), pass_rect);
- root_pass->quad_list.push_back(CreateTestRenderPassDrawQuad(
- pass_shared_state, pass_rect, child_pass_id));
+ CreateTestSharedQuadState(gfx::Transform(), pass_rect, root_pass.get());
+ CreateTestRenderPassDrawQuad(
+ pass_shared_state, pass_rect, child_pass_id, root_pass.get());
RenderPassList pass_list;
pass_list.push_back(child_pass.Pass());
pass_list.push_back(root_pass.Pass());
@@ -1584,10 +1547,10 @@ TEST_F(ExternalStencilPixelTest, DeviceClip) {
RenderPass::Id id(1, 1);
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
SharedQuadState* blue_shared_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
- scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create();
+ CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
+ SolidColorDrawQuad* blue =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false);
- pass->quad_list.push_back(blue.PassAs<DrawQuad>());
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -1607,32 +1570,28 @@ TEST_F(GLRendererPixelTest, AntiAliasing) {
gfx::Transform red_content_to_target_transform;
red_content_to_target_transform.Rotate(10);
SharedQuadState* red_shared_state = CreateTestSharedQuadState(
- pass.get(), red_content_to_target_transform, rect);
+ red_content_to_target_transform, rect, pass.get());
- scoped_ptr<SolidColorDrawQuad> red = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
red->SetNew(red_shared_state, rect, rect, SK_ColorRED, false);
- pass->quad_list.push_back(red.PassAs<DrawQuad>());
-
gfx::Transform yellow_content_to_target_transform;
yellow_content_to_target_transform.Rotate(5);
SharedQuadState* yellow_shared_state = CreateTestSharedQuadState(
- pass.get(), yellow_content_to_target_transform, rect);
+ yellow_content_to_target_transform, rect, pass.get());
- scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* yellow =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
yellow->SetNew(yellow_shared_state, rect, rect, SK_ColorYELLOW, false);
- pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
-
gfx::Transform blue_content_to_target_transform;
SharedQuadState* blue_shared_state = CreateTestSharedQuadState(
- pass.get(), blue_content_to_target_transform, rect);
+ blue_content_to_target_transform, rect, pass.get());
- scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* blue =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false);
- pass->quad_list.push_back(blue.PassAs<DrawQuad>());
-
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -1658,33 +1617,29 @@ TEST_F(GLRendererPixelTest, AxisAligned) {
0.5f + 1.0f / (rect.width() * 2.0f),
0.5f + 1.0f / (rect.height() * 2.0f));
SharedQuadState* red_shared_state = CreateTestSharedQuadState(
- pass.get(), red_content_to_target_transform, rect);
+ red_content_to_target_transform, rect, pass.get());
- scoped_ptr<SolidColorDrawQuad> red = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
red->SetNew(red_shared_state, rect, rect, SK_ColorRED, false);
- pass->quad_list.push_back(red.PassAs<DrawQuad>());
-
gfx::Transform yellow_content_to_target_transform;
yellow_content_to_target_transform.Translate(25.5f, 25.5f);
yellow_content_to_target_transform.Scale(0.5f, 0.5f);
SharedQuadState* yellow_shared_state = CreateTestSharedQuadState(
- pass.get(), yellow_content_to_target_transform, rect);
+ yellow_content_to_target_transform, rect, pass.get());
- scoped_ptr<SolidColorDrawQuad> yellow = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* yellow =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
yellow->SetNew(yellow_shared_state, rect, rect, SK_ColorYELLOW, false);
- pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
-
gfx::Transform blue_content_to_target_transform;
SharedQuadState* blue_shared_state = CreateTestSharedQuadState(
- pass.get(), blue_content_to_target_transform, rect);
+ blue_content_to_target_transform, rect, pass.get());
- scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* blue =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false);
- pass->quad_list.push_back(blue.PassAs<DrawQuad>());
-
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -1710,22 +1665,21 @@ TEST_F(GLRendererPixelTest, ForceAntiAliasingOff) {
0.5f + 1.0f / (rect.width() * 2.0f),
0.5f + 1.0f / (rect.height() * 2.0f));
SharedQuadState* hole_shared_state = CreateTestSharedQuadState(
- pass.get(), hole_content_to_target_transform, rect);
+ hole_content_to_target_transform, rect, pass.get());
- scoped_ptr<SolidColorDrawQuad> hole = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* hole =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
hole->SetAll(
hole_shared_state, rect, rect, rect, false, SK_ColorTRANSPARENT, true);
- pass->quad_list.push_back(hole.PassAs<DrawQuad>());
gfx::Transform green_content_to_target_transform;
SharedQuadState* green_shared_state = CreateTestSharedQuadState(
- pass.get(), green_content_to_target_transform, rect);
+ green_content_to_target_transform, rect, pass.get());
- scoped_ptr<SolidColorDrawQuad> green = SolidColorDrawQuad::Create();
+ SolidColorDrawQuad* green =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
green->SetNew(green_shared_state, rect, rect, SK_ColorGREEN, false);
- pass->quad_list.push_back(green.PassAs<DrawQuad>());
-
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -1748,24 +1702,23 @@ TEST_F(GLRendererPixelTest, AntiAliasingPerspective) {
0.0f, -0.2250f, -0.9744f, 0.0f,
0.0f, 0.0225f, 0.0974f, 1.0f);
SharedQuadState* red_shared_state = CreateTestSharedQuadState(
- pass.get(), red_content_to_target_transform, red_rect);
- scoped_ptr<SolidColorDrawQuad> red = SolidColorDrawQuad::Create();
+ red_content_to_target_transform, red_rect, pass.get());
+ SolidColorDrawQuad* red = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
red->SetNew(red_shared_state, red_rect, red_rect, SK_ColorRED, false);
- pass->quad_list.push_back(red.PassAs<DrawQuad>());
gfx::Rect green_rect(19, 7, 180, 10);
SharedQuadState* green_shared_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), green_rect);
- scoped_ptr<SolidColorDrawQuad> green = SolidColorDrawQuad::Create();
+ CreateTestSharedQuadState(gfx::Transform(), green_rect, pass.get());
+ SolidColorDrawQuad* green =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
green->SetNew(
green_shared_state, green_rect, green_rect, SK_ColorGREEN, false);
- pass->quad_list.push_back(green.PassAs<DrawQuad>());
SharedQuadState* blue_shared_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
- scoped_ptr<SolidColorDrawQuad> blue = SolidColorDrawQuad::Create();
+ CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
+ SolidColorDrawQuad* blue =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false);
- pass->quad_list.push_back(blue.PassAs<DrawQuad>());
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -1807,12 +1760,12 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadIdentityScale) {
gfx::RectF blue_scissor_rect = blue_clip_rect;
blue_content_to_target_transform.TransformRect(&blue_scissor_rect);
SharedQuadState* blue_shared_state =
- CreateTestSharedQuadStateClipped(pass.get(),
- blue_content_to_target_transform,
+ CreateTestSharedQuadStateClipped(blue_content_to_target_transform,
blue_rect,
- gfx::ToEnclosingRect(blue_scissor_rect));
+ gfx::ToEnclosingRect(blue_scissor_rect),
+ pass.get());
- scoped_ptr<PictureDrawQuad> blue_quad = PictureDrawQuad::Create();
+ PictureDrawQuad* blue_quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
blue_quad->SetNew(blue_shared_state,
viewport, // Intentionally bigger than clip.
@@ -1824,7 +1777,6 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadIdentityScale) {
viewport,
1.f,
PicturePileImpl::CreateFromOther(blue_pile));
- pass->quad_list.push_back(blue_quad.PassAs<DrawQuad>());
// One viewport-filling green quad.
scoped_refptr<FakePicturePileImpl> green_pile =
@@ -1836,9 +1788,10 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadIdentityScale) {
gfx::Transform green_content_to_target_transform;
SharedQuadState* green_shared_state = CreateTestSharedQuadState(
- pass.get(), green_content_to_target_transform, viewport);
+ green_content_to_target_transform, viewport, pass.get());
- scoped_ptr<PictureDrawQuad> green_quad = PictureDrawQuad::Create();
+ PictureDrawQuad* green_quad =
+ pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
green_quad->SetNew(green_shared_state,
viewport,
gfx::Rect(),
@@ -1849,7 +1802,6 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadIdentityScale) {
viewport,
1.f,
PicturePileImpl::CreateFromOther(green_pile));
- pass->quad_list.push_back(green_quad.PassAs<DrawQuad>());
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -1881,10 +1833,11 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadOpacity) {
gfx::Transform green_content_to_target_transform;
SharedQuadState* green_shared_state = CreateTestSharedQuadState(
- pass.get(), green_content_to_target_transform, viewport);
+ green_content_to_target_transform, viewport, pass.get());
green_shared_state->opacity = 0.5f;
- scoped_ptr<PictureDrawQuad> green_quad = PictureDrawQuad::Create();
+ PictureDrawQuad* green_quad =
+ pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
green_quad->SetNew(green_shared_state,
viewport,
gfx::Rect(),
@@ -1895,7 +1848,6 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadOpacity) {
viewport,
1.f,
PicturePileImpl::CreateFromOther(green_pile));
- pass->quad_list.push_back(green_quad.PassAs<DrawQuad>());
// One viewport-filling white quad.
scoped_refptr<FakePicturePileImpl> white_pile =
@@ -1907,9 +1859,10 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadOpacity) {
gfx::Transform white_content_to_target_transform;
SharedQuadState* white_shared_state = CreateTestSharedQuadState(
- pass.get(), white_content_to_target_transform, viewport);
+ white_content_to_target_transform, viewport, pass.get());
- scoped_ptr<PictureDrawQuad> white_quad = PictureDrawQuad::Create();
+ PictureDrawQuad* white_quad =
+ pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
white_quad->SetNew(white_shared_state,
viewport,
gfx::Rect(),
@@ -1920,7 +1873,6 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadOpacity) {
viewport,
1.f,
PicturePileImpl::CreateFromOther(white_pile));
- pass->quad_list.push_back(white_quad.PassAs<DrawQuad>());
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -1982,9 +1934,9 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadDisableImageFiltering) {
gfx::Transform content_to_target_transform;
SharedQuadState* shared_state = CreateTestSharedQuadState(
- pass.get(), content_to_target_transform, viewport);
+ content_to_target_transform, viewport, pass.get());
- scoped_ptr<PictureDrawQuad> quad = PictureDrawQuad::Create();
+ PictureDrawQuad* quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
quad->SetNew(shared_state,
viewport,
gfx::Rect(),
@@ -1995,7 +1947,6 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadDisableImageFiltering) {
viewport,
1.f,
PicturePileImpl::CreateFromOther(pile));
- pass->quad_list.push_back(quad.PassAs<DrawQuad>());
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -2039,9 +1990,10 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) {
SharedQuadState* top_right_green_shared_quad_state =
CreateTestSharedQuadState(
- pass.get(), green_content_to_target_transform, viewport);
+ green_content_to_target_transform, viewport, pass.get());
- scoped_ptr<PictureDrawQuad> green_quad1 = PictureDrawQuad::Create();
+ PictureDrawQuad* green_quad1 =
+ pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
green_quad1->SetNew(top_right_green_shared_quad_state,
green_rect1,
gfx::Rect(),
@@ -2052,9 +2004,9 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) {
green_rect1,
1.f,
PicturePileImpl::CreateFromOther(green_pile));
- pass->quad_list.push_back(green_quad1.PassAs<DrawQuad>());
- scoped_ptr<PictureDrawQuad> green_quad2 = PictureDrawQuad::Create();
+ PictureDrawQuad* green_quad2 =
+ pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
green_quad2->SetNew(top_right_green_shared_quad_state,
green_rect2,
gfx::Rect(),
@@ -2065,7 +2017,6 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) {
green_rect2,
1.f,
PicturePileImpl::CreateFromOther(green_pile));
- pass->quad_list.push_back(green_quad2.PassAs<DrawQuad>());
// Add a green clipped checkerboard in the bottom right to help test
// interleaving picture quad content and solid color content.
@@ -2073,18 +2024,17 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) {
gfx::Point(viewport.width() / 2, viewport.height() / 2),
gfx::Size(viewport.width() / 2, viewport.height() / 2));
SharedQuadState* bottom_right_green_shared_state =
- CreateTestSharedQuadStateClipped(pass.get(),
- green_content_to_target_transform,
+ CreateTestSharedQuadStateClipped(green_content_to_target_transform,
viewport,
- bottom_right_rect);
- scoped_ptr<SolidColorDrawQuad> bottom_right_color_quad =
- SolidColorDrawQuad::Create();
+ bottom_right_rect,
+ pass.get());
+ SolidColorDrawQuad* bottom_right_color_quad =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
bottom_right_color_quad->SetNew(bottom_right_green_shared_state,
viewport,
viewport,
SK_ColorGREEN,
false);
- pass->quad_list.push_back(bottom_right_color_quad.PassAs<DrawQuad>());
// Add two blue checkerboards taking up the bottom left and top right,
// but use content scales as content rects to make this happen.
@@ -2129,9 +2079,9 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) {
content_to_target_transform.Scale(10.0, 10.0);
gfx::Rect quad_content_rect(gfx::Size(20, 20));
SharedQuadState* blue_shared_state = CreateTestSharedQuadState(
- pass.get(), content_to_target_transform, quad_content_rect);
+ content_to_target_transform, quad_content_rect, pass.get());
- scoped_ptr<PictureDrawQuad> blue_quad = PictureDrawQuad::Create();
+ PictureDrawQuad* blue_quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
blue_quad->SetNew(blue_shared_state,
quad_content_rect,
gfx::Rect(),
@@ -2142,20 +2092,19 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) {
content_union_rect,
contents_scale,
PicturePileImpl::CreateFromOther(pile));
- pass->quad_list.push_back(blue_quad.PassAs<DrawQuad>());
// Fill left half of viewport with green.
gfx::Transform half_green_content_to_target_transform;
gfx::Rect half_green_rect(gfx::Size(viewport.width() / 2, viewport.height()));
SharedQuadState* half_green_shared_state = CreateTestSharedQuadState(
- pass.get(), half_green_content_to_target_transform, half_green_rect);
- scoped_ptr<SolidColorDrawQuad> half_color_quad = SolidColorDrawQuad::Create();
+ half_green_content_to_target_transform, half_green_rect, pass.get());
+ SolidColorDrawQuad* half_color_quad =
+ pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
half_color_quad->SetNew(half_green_shared_state,
half_green_rect,
half_green_rect,
SK_ColorGREEN,
false);
- pass->quad_list.push_back(half_color_quad.PassAs<DrawQuad>());
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
@@ -2173,7 +2122,7 @@ TYPED_TEST(RendererPixelTest, WrapModeRepeat) {
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
SharedQuadState* shared_state =
- CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
+ CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
gfx::Rect texture_rect(4, 4);
SkPMColor colors[4] = {
@@ -2202,7 +2151,8 @@ TYPED_TEST(RendererPixelTest, WrapModeRepeat) {
gfx::Vector2d());
float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f};
- scoped_ptr<TextureDrawQuad> texture_quad = TextureDrawQuad::Create();
+ TextureDrawQuad* texture_quad =
+ pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
texture_quad->SetNew(
shared_state,
gfx::Rect(this->device_viewport_size_),
@@ -2217,7 +2167,6 @@ TYPED_TEST(RendererPixelTest, WrapModeRepeat) {
SK_ColorWHITE,
vertex_opacity,
false); // flipped
- pass->quad_list.push_back(texture_quad.PassAs<DrawQuad>());
RenderPassList pass_list;
pass_list.push_back(pass.Pass());
« no previous file with comments | « cc/output/overlay_unittest.cc ('k') | cc/output/software_renderer_unittest.cc » ('j') | cc/quads/render_pass.cc » ('J')

Powered by Google App Engine
This is Rietveld 408576698