From 2b7f389bd690d17ce59dc8e42470d1d0ec7c1b26 Mon Sep 17 00:00:00 2001 From: "weiliangc@chromium.org" Date: Thu, 8 May 2014 01:45:18 +0000 Subject: [PATCH] Use RenderPass CreateAndAppendSQS whenever possible This CL is a follow up on 265823015. Now RenderPass has function to create and append SharedQuadState without passing around the owndership, use this function whenever possible, instead of create SQS and pass it into RenderPass. This CL also helps future CL that will expose the default constructor of SQS, and remove scoped_ptr constructor. BUG=344962 TEST=cc_unittests, content_unittests, content_perftests Review URL: https://codereview.chromium.org/271703003 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@269013 0039d316-1c4b-4281-b951-d872f2087c98 --- cc/layers/delegated_frame_provider_unittest.cc | 6 +- cc/output/overlay_unittest.cc | 3 +- cc/output/renderer_pixeltest.cc | 522 ++++++++++++------------- cc/output/software_renderer_unittest.cc | 43 +- cc/quads/render_pass_unittest.cc | 25 +- cc/surfaces/surface_aggregator_test_helpers.cc | 3 +- cc/surfaces/surface_aggregator_unittest.cc | 3 +- cc/surfaces/surfaces_pixeltest.cc | 35 +- cc/test/render_pass_test_common.cc | 41 +- cc/test/render_pass_test_common.h | 1 - cc/trees/layer_tree_host_unittest_delegated.cc | 19 +- content/common/cc_messages.cc | 5 +- content/common/cc_messages_perftest.cc | 10 +- content/common/cc_messages_unittest.cc | 102 +++-- 14 files changed, 389 insertions(+), 429 deletions(-) diff --git a/cc/layers/delegated_frame_provider_unittest.cc b/cc/layers/delegated_frame_provider_unittest.cc index a8e1683e045f..0655cf36e72f 100644 --- a/cc/layers/delegated_frame_provider_unittest.cc +++ b/cc/layers/delegated_frame_provider_unittest.cc @@ -44,10 +44,11 @@ class DelegatedFrameProviderTest void AddTextureQuad(DelegatedFrameData* frame, ResourceProvider::ResourceId resource_id) { - scoped_ptr sqs = SharedQuadState::Create(); + SharedQuadState* sqs = + frame->render_pass_list[0]->CreateAndAppendSharedQuadState(); scoped_ptr quad = TextureDrawQuad::Create(); float vertex_opacity[4] = {1.f, 1.f, 1.f, 1.f}; - quad->SetNew(sqs.get(), + quad->SetNew(sqs, gfx::Rect(0, 0, 10, 10), gfx::Rect(0, 0, 10, 10), gfx::Rect(0, 0, 10, 10), @@ -58,7 +59,6 @@ class DelegatedFrameProviderTest SK_ColorTRANSPARENT, vertex_opacity, false); - frame->render_pass_list[0]->shared_quad_state_list.push_back(sqs.Pass()); frame->render_pass_list[0]->quad_list.push_back(quad.PassAs()); } diff --git a/cc/output/overlay_unittest.cc b/cc/output/overlay_unittest.cc index c258c9d48737..69c11c0dd225 100644 --- a/cc/output/overlay_unittest.cc +++ b/cc/output/overlay_unittest.cc @@ -111,9 +111,8 @@ scoped_ptr CreateRenderPass() { gfx::Transform(), has_transparent_background); - scoped_ptr shared_state = SharedQuadState::Create(); + SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); shared_state->opacity = 1.f; - pass->shared_quad_state_list.push_back(shared_state.Pass()); return pass.Pass(); } diff --git a/cc/output/renderer_pixeltest.cc b/cc/output/renderer_pixeltest.cc index 869bb9b0c2ac..291563bb0f3c 100644 --- a/cc/output/renderer_pixeltest.cc +++ b/cc/output/renderer_pixeltest.cc @@ -48,15 +48,17 @@ scoped_ptr CreateTestRenderPass( return pass.Pass(); } -scoped_ptr CreateTestSharedQuadState( - gfx::Transform content_to_target_transform, const gfx::Rect& rect) { +SharedQuadState* CreateTestSharedQuadState( + RenderPass* render_pass, + gfx::Transform content_to_target_transform, + const gfx::Rect& rect) { const gfx::Size content_bounds = rect.size(); const gfx::Rect visible_content_rect = rect; const gfx::Rect clip_rect = rect; const bool is_clipped = false; const float opacity = 1.0f; const SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode; - scoped_ptr shared_state = SharedQuadState::Create(); + SharedQuadState* shared_state = render_pass->CreateAndAppendSharedQuadState(); shared_state->SetAll(content_to_target_transform, content_bounds, visible_content_rect, @@ -64,10 +66,11 @@ scoped_ptr CreateTestSharedQuadState( is_clipped, opacity, blend_mode); - return shared_state.Pass(); + return shared_state; } -scoped_ptr CreateTestSharedQuadStateClipped( +SharedQuadState* CreateTestSharedQuadStateClipped( + RenderPass* render_pass, gfx::Transform content_to_target_transform, const gfx::Rect& rect, const gfx::Rect& clip_rect) { @@ -76,7 +79,7 @@ scoped_ptr CreateTestSharedQuadStateClipped( const bool is_clipped = true; const float opacity = 1.0f; const SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode; - scoped_ptr shared_state = SharedQuadState::Create(); + SharedQuadState* shared_state = render_pass->CreateAndAppendSharedQuadState(); shared_state->SetAll(content_to_target_transform, content_bounds, visible_content_rect, @@ -84,7 +87,7 @@ scoped_ptr CreateTestSharedQuadStateClipped( is_clipped, opacity, blend_mode); - return shared_state.Pass(); + return shared_state; } scoped_ptr CreateTestRenderPassDrawQuad( @@ -205,11 +208,11 @@ TYPED_TEST(RendererPixelTest, SimpleGreenRect) { RenderPass::Id id(1, 1); scoped_ptr pass = CreateTestRootRenderPass(id, rect); - scoped_ptr shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(shared_state.get(), rect, rect, SK_ColorGREEN, false); + color_quad->SetNew(shared_state, rect, rect, SK_ColorGREEN, false); pass->quad_list.push_back(color_quad.PassAs()); @@ -230,25 +233,22 @@ TYPED_TEST(RendererPixelTest, SimpleGreenRect_NonRootRenderPass) { scoped_ptr child_pass = CreateTestRenderPass(child_id, small_rect, gfx::Transform()); - scoped_ptr child_shared_state = - CreateTestSharedQuadState(gfx::Transform(), small_rect); + SharedQuadState* child_shared_state = + CreateTestSharedQuadState(child_pass.get(), gfx::Transform(), small_rect); scoped_ptr color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew( - child_shared_state.get(), rect, rect, SK_ColorGREEN, false); + color_quad->SetNew(child_shared_state, rect, rect, SK_ColorGREEN, false); child_pass->quad_list.push_back(color_quad.PassAs()); RenderPass::Id root_id(1, 1); scoped_ptr root_pass = CreateTestRenderPass(root_id, rect, gfx::Transform()); - scoped_ptr root_shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* root_shared_state = + CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), rect); scoped_ptr render_pass_quad = - CreateTestRenderPassDrawQuad(root_shared_state.get(), - small_rect, - child_id); + CreateTestRenderPassDrawQuad(root_shared_state, small_rect, child_id); root_pass->quad_list.push_back(render_pass_quad.PassAs()); RenderPass* child_pass_ptr = child_pass.get(); @@ -270,20 +270,20 @@ TYPED_TEST(RendererPixelTest, PremultipliedTextureWithoutBackground) { RenderPass::Id id(1, 1); scoped_ptr pass = CreateTestRootRenderPass(id, rect); - scoped_ptr shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); - scoped_ptr 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.get(), - this->resource_provider_.get()); + scoped_ptr 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()); scoped_ptr color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(shared_state.get(), rect, rect, SK_ColorWHITE, false); + color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false); pass->quad_list.push_back(color_quad.PassAs()); RenderPassList pass_list; @@ -301,23 +301,23 @@ TYPED_TEST(RendererPixelTest, PremultipliedTextureWithBackground) { RenderPass::Id id(1, 1); scoped_ptr pass = CreateTestRootRenderPass(id, rect); - scoped_ptr texture_quad_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* texture_quad_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); texture_quad_state->opacity = 0.8f; scoped_ptr 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.get(), + SK_ColorGREEN, // Background color. + true, // Premultiplied alpha. + texture_quad_state, this->resource_provider_.get()); pass->quad_list.push_back(texture_quad.PassAs()); - scoped_ptr color_quad_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* color_quad_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(color_quad_state.get(), rect, rect, SK_ColorWHITE, false); + color_quad->SetNew(color_quad_state, rect, rect, SK_ColorWHITE, false); pass->quad_list.push_back(color_quad.PassAs()); RenderPassList pass_list; @@ -336,20 +336,20 @@ TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithoutBackground) { RenderPass::Id id(1, 1); scoped_ptr pass = CreateTestRootRenderPass(id, rect); - scoped_ptr shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); - scoped_ptr 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.get(), - this->resource_provider_.get()); + scoped_ptr 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()); scoped_ptr color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(shared_state.get(), rect, rect, SK_ColorWHITE, false); + color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false); pass->quad_list.push_back(color_quad.PassAs()); RenderPassList pass_list; @@ -368,23 +368,23 @@ TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithBackground) { RenderPass::Id id(1, 1); scoped_ptr pass = CreateTestRootRenderPass(id, rect); - scoped_ptr texture_quad_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* texture_quad_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); texture_quad_state->opacity = 0.8f; scoped_ptr 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.get(), + SK_ColorGREEN, // Background color. + false, // Premultiplied alpha. + texture_quad_state, this->resource_provider_.get()); pass->quad_list.push_back(texture_quad.PassAs()); - scoped_ptr color_quad_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* color_quad_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(color_quad_state.get(), rect, rect, SK_ColorWHITE, false); + color_quad->SetNew(color_quad_state, rect, rect, SK_ColorWHITE, false); pass->quad_list.push_back(color_quad.PassAs()); RenderPassList pass_list; @@ -552,11 +552,11 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVRect) { RenderPass::Id id(1, 1); scoped_ptr pass = CreateTestRootRenderPass(id, rect); - scoped_ptr shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr yuv_quad = - CreateTestYUVVideoDrawQuad_Striped(shared_state.get(), + CreateTestYUVVideoDrawQuad_Striped(shared_state, media::VideoFrame::YV12, false, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f)); @@ -578,12 +578,12 @@ TEST_F(VideoGLRendererPixelTest, OffsetYUVRect) { RenderPass::Id id(1, 1); scoped_ptr pass = CreateTestRootRenderPass(id, rect); - scoped_ptr shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); // Intentionally sets frame format to I420 for testing coverage. scoped_ptr yuv_quad = CreateTestYUVVideoDrawQuad_Striped( - shared_state.get(), + shared_state, media::VideoFrame::I420, false, gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f)); @@ -605,12 +605,12 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVRectBlack) { RenderPass::Id id(1, 1); scoped_ptr pass = CreateTestRootRenderPass(id, rect); - scoped_ptr shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); // In MPEG color range YUV values of (15,128,128) should produce black. scoped_ptr yuv_quad = - CreateTestYUVVideoDrawQuad_Solid(shared_state.get(), + CreateTestYUVVideoDrawQuad_Solid(shared_state, media::VideoFrame::YV12, false, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), @@ -636,12 +636,12 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVJRect) { RenderPass::Id id(1, 1); scoped_ptr pass = CreateTestRootRenderPass(id, rect); - scoped_ptr shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); // YUV of (149,43,21) should be green (0,255,0) in RGB. scoped_ptr yuv_quad = - CreateTestYUVVideoDrawQuad_Solid(shared_state.get(), + CreateTestYUVVideoDrawQuad_Solid(shared_state, media::VideoFrame::YV12J, false, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), @@ -665,12 +665,12 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVJRectGrey) { RenderPass::Id id(1, 1); scoped_ptr pass = CreateTestRootRenderPass(id, rect); - scoped_ptr shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); // Dark grey in JPEG color range (in MPEG, this is black). scoped_ptr yuv_quad = - CreateTestYUVVideoDrawQuad_Solid(shared_state.get(), + CreateTestYUVVideoDrawQuad_Solid(shared_state, media::VideoFrame::YV12J, false, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), @@ -695,11 +695,11 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) { RenderPass::Id id(1, 1); scoped_ptr pass = CreateTestRootRenderPass(id, rect); - scoped_ptr shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr yuv_quad = - CreateTestYUVVideoDrawQuad_Striped(shared_state.get(), + CreateTestYUVVideoDrawQuad_Striped(shared_state, media::VideoFrame::YV12A, false, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f)); @@ -707,7 +707,7 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) { pass->quad_list.push_back(yuv_quad.PassAs()); scoped_ptr color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(shared_state.get(), rect, rect, SK_ColorWHITE, false); + color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false); pass->quad_list.push_back(color_quad.PassAs()); @@ -726,11 +726,11 @@ TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) { RenderPass::Id id(1, 1); scoped_ptr pass = CreateTestRootRenderPass(id, rect); - scoped_ptr shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr yuv_quad = - CreateTestYUVVideoDrawQuad_Striped(shared_state.get(), + CreateTestYUVVideoDrawQuad_Striped(shared_state, media::VideoFrame::YV12A, true, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f)); @@ -738,7 +738,7 @@ TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) { pass->quad_list.push_back(yuv_quad.PassAs()); scoped_ptr color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(shared_state.get(), rect, rect, SK_ColorBLACK, false); + color_quad->SetNew(shared_state, rect, rect, SK_ColorBLACK, false); pass->quad_list.push_back(color_quad.PassAs()); @@ -765,8 +765,8 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) { CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); gfx::Transform content_to_target_transform; - scoped_ptr shared_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); shared_state->opacity = 0.5f; gfx::Rect blue_rect(0, @@ -774,28 +774,27 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) { this->device_viewport_size_.width(), this->device_viewport_size_.height() / 2); scoped_ptr blue = SolidColorDrawQuad::Create(); - blue->SetNew(shared_state.get(), blue_rect, blue_rect, SK_ColorBLUE, false); + 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 yellow = SolidColorDrawQuad::Create(); - yellow->SetNew( - shared_state.get(), yellow_rect, yellow_rect, SK_ColorYELLOW, false); + yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false); - scoped_ptr blank_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* blank_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); scoped_ptr white = SolidColorDrawQuad::Create(); white->SetNew( - blank_state.get(), viewport_rect, viewport_rect, SK_ColorWHITE, false); + blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false); child_pass->quad_list.push_back(blue.PassAs()); child_pass->quad_list.push_back(yellow.PassAs()); child_pass->quad_list.push_back(white.PassAs()); - scoped_ptr pass_shared_state = - CreateTestSharedQuadState(gfx::Transform(), pass_rect); + SharedQuadState* pass_shared_state = + CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), pass_rect); SkScalar matrix[20]; float amount = 0.5f; @@ -822,7 +821,7 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) { scoped_ptr render_pass_quad = RenderPassDrawQuad::Create(); - render_pass_quad->SetNew(pass_shared_state.get(), + render_pass_quad->SetNew(pass_shared_state, pass_rect, pass_rect, child_pass_id, @@ -861,8 +860,8 @@ TYPED_TEST(RendererPixelTest, FastPassSaturateFilter) { CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); gfx::Transform content_to_target_transform; - scoped_ptr shared_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); shared_state->opacity = 0.5f; gfx::Rect blue_rect(0, @@ -870,35 +869,34 @@ TYPED_TEST(RendererPixelTest, FastPassSaturateFilter) { this->device_viewport_size_.width(), this->device_viewport_size_.height() / 2); scoped_ptr blue = SolidColorDrawQuad::Create(); - blue->SetNew(shared_state.get(), blue_rect, blue_rect, SK_ColorBLUE, false); + 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 yellow = SolidColorDrawQuad::Create(); - yellow->SetNew( - shared_state.get(), yellow_rect, yellow_rect, SK_ColorYELLOW, false); + yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false); - scoped_ptr blank_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* blank_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); scoped_ptr white = SolidColorDrawQuad::Create(); white->SetNew( - blank_state.get(), viewport_rect, viewport_rect, SK_ColorWHITE, false); + blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false); child_pass->quad_list.push_back(blue.PassAs()); child_pass->quad_list.push_back(yellow.PassAs()); child_pass->quad_list.push_back(white.PassAs()); - scoped_ptr pass_shared_state = - CreateTestSharedQuadState(gfx::Transform(), pass_rect); + SharedQuadState* pass_shared_state = + CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), pass_rect); FilterOperations filters; filters.Append(FilterOperation::CreateSaturateFilter(0.5f)); scoped_ptr render_pass_quad = RenderPassDrawQuad::Create(); - render_pass_quad->SetNew(pass_shared_state.get(), + render_pass_quad->SetNew(pass_shared_state, pass_rect, pass_rect, child_pass_id, @@ -935,8 +933,8 @@ TYPED_TEST(RendererPixelTest, FastPassFilterChain) { CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); gfx::Transform content_to_target_transform; - scoped_ptr shared_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); shared_state->opacity = 0.5f; gfx::Rect blue_rect(0, @@ -944,28 +942,27 @@ TYPED_TEST(RendererPixelTest, FastPassFilterChain) { this->device_viewport_size_.width(), this->device_viewport_size_.height() / 2); scoped_ptr blue = SolidColorDrawQuad::Create(); - blue->SetNew(shared_state.get(), blue_rect, blue_rect, SK_ColorBLUE, false); + 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 yellow = SolidColorDrawQuad::Create(); - yellow->SetNew( - shared_state.get(), yellow_rect, yellow_rect, SK_ColorYELLOW, false); + yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false); - scoped_ptr blank_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* blank_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); scoped_ptr white = SolidColorDrawQuad::Create(); white->SetNew( - blank_state.get(), viewport_rect, viewport_rect, SK_ColorWHITE, false); + blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false); child_pass->quad_list.push_back(blue.PassAs()); child_pass->quad_list.push_back(yellow.PassAs()); child_pass->quad_list.push_back(white.PassAs()); - scoped_ptr pass_shared_state = - CreateTestSharedQuadState(gfx::Transform(), pass_rect); + SharedQuadState* pass_shared_state = + CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), pass_rect); FilterOperations filters; filters.Append(FilterOperation::CreateGrayscaleFilter(1.f)); @@ -973,7 +970,7 @@ TYPED_TEST(RendererPixelTest, FastPassFilterChain) { scoped_ptr render_pass_quad = RenderPassDrawQuad::Create(); - render_pass_quad->SetNew(pass_shared_state.get(), + render_pass_quad->SetNew(pass_shared_state, pass_rect, pass_rect, child_pass_id, @@ -1010,8 +1007,8 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) { CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); gfx::Transform content_to_target_transform; - scoped_ptr shared_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); shared_state->opacity = 0.5f; gfx::Rect blue_rect(0, @@ -1019,28 +1016,27 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) { this->device_viewport_size_.width(), this->device_viewport_size_.height() / 2); scoped_ptr blue = SolidColorDrawQuad::Create(); - blue->SetNew(shared_state.get(), blue_rect, blue_rect, SK_ColorBLUE, false); + 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 yellow = SolidColorDrawQuad::Create(); - yellow->SetNew( - shared_state.get(), yellow_rect, yellow_rect, SK_ColorYELLOW, false); + yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false); - scoped_ptr blank_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* blank_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); scoped_ptr white = SolidColorDrawQuad::Create(); white->SetNew( - blank_state.get(), viewport_rect, viewport_rect, SK_ColorWHITE, false); + blank_state, viewport_rect, viewport_rect, SK_ColorWHITE, false); child_pass->quad_list.push_back(blue.PassAs()); child_pass->quad_list.push_back(yellow.PassAs()); child_pass->quad_list.push_back(white.PassAs()); - scoped_ptr pass_shared_state = - CreateTestSharedQuadState(gfx::Transform(), pass_rect); + SharedQuadState* pass_shared_state = + CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), pass_rect); SkScalar matrix[20]; float amount = 0.5f; @@ -1070,7 +1066,7 @@ TYPED_TEST(RendererPixelTest, FastPassColorFilterAlphaTranslation) { scoped_ptr render_pass_quad = RenderPassDrawQuad::Create(); - render_pass_quad->SetNew(pass_shared_state.get(), + render_pass_quad->SetNew(pass_shared_state, pass_rect, pass_rect, child_pass_id, @@ -1109,32 +1105,29 @@ TYPED_TEST(RendererPixelTest, EnlargedRenderPassTexture) { CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); gfx::Transform content_to_target_transform; - scoped_ptr shared_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); gfx::Rect blue_rect(0, 0, this->device_viewport_size_.width(), this->device_viewport_size_.height() / 2); scoped_ptr blue = SolidColorDrawQuad::Create(); - blue->SetNew(shared_state.get(), blue_rect, blue_rect, SK_ColorBLUE, false); + 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 yellow = SolidColorDrawQuad::Create(); - yellow->SetNew( - shared_state.get(), yellow_rect, yellow_rect, SK_ColorYELLOW, false); + yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false); child_pass->quad_list.push_back(blue.PassAs()); child_pass->quad_list.push_back(yellow.PassAs()); - scoped_ptr pass_shared_state = - CreateTestSharedQuadState(gfx::Transform(), pass_rect); - root_pass->quad_list.push_back( - CreateTestRenderPassDrawQuad(pass_shared_state.get(), - pass_rect, - child_pass_id)); + 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)); RenderPassList pass_list; pass_list.push_back(child_pass.Pass()); @@ -1162,22 +1155,21 @@ TYPED_TEST(RendererPixelTest, EnlargedRenderPassTextureWithAntiAliasing) { CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); gfx::Transform content_to_target_transform; - scoped_ptr shared_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); gfx::Rect blue_rect(0, 0, this->device_viewport_size_.width(), this->device_viewport_size_.height() / 2); scoped_ptr blue = SolidColorDrawQuad::Create(); - blue->SetNew(shared_state.get(), blue_rect, blue_rect, SK_ColorBLUE, false); + 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 yellow = SolidColorDrawQuad::Create(); - yellow->SetNew( - shared_state.get(), yellow_rect, yellow_rect, SK_ColorYELLOW, false); + yellow->SetNew(shared_state, yellow_rect, yellow_rect, SK_ColorYELLOW, false); child_pass->quad_list.push_back(blue.PassAs()); child_pass->quad_list.push_back(yellow.PassAs()); @@ -1185,17 +1177,15 @@ TYPED_TEST(RendererPixelTest, EnlargedRenderPassTextureWithAntiAliasing) { gfx::Transform aa_transform; aa_transform.Translate(0.5, 0.0); - scoped_ptr pass_shared_state = - CreateTestSharedQuadState(aa_transform, pass_rect); - root_pass->quad_list.push_back( - CreateTestRenderPassDrawQuad(pass_shared_state.get(), - pass_rect, - child_pass_id)); + 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)); - scoped_ptr root_shared_state = - CreateTestSharedQuadState(gfx::Transform(), viewport_rect); + SharedQuadState* root_shared_state = CreateTestSharedQuadState( + root_pass.get(), gfx::Transform(), viewport_rect); scoped_ptr background = SolidColorDrawQuad::Create(); - background->SetNew(root_shared_state.get(), + background->SetNew(root_shared_state, gfx::Rect(this->device_viewport_size_), gfx::Rect(this->device_viewport_size_), SK_ColorWHITE, @@ -1222,24 +1212,21 @@ TYPED_TEST(RendererPixelTest, RenderPassAndMaskWithPartialQuad) { RenderPass::Id root_pass_id(1, 1); scoped_ptr root_pass = CreateTestRootRenderPass(root_pass_id, viewport_rect); - scoped_ptr root_pass_shared_state = - CreateTestSharedQuadState(gfx::Transform(), viewport_rect); + SharedQuadState* root_pass_shared_state = CreateTestSharedQuadState( + root_pass.get(), gfx::Transform(), viewport_rect); RenderPass::Id child_pass_id(2, 2); gfx::Transform transform_to_root; scoped_ptr child_pass = CreateTestRenderPass(child_pass_id, viewport_rect, transform_to_root); - scoped_ptr child_pass_shared_state = - CreateTestSharedQuadState(gfx::Transform(), viewport_rect); + SharedQuadState* child_pass_shared_state = CreateTestSharedQuadState( + child_pass.get(), gfx::Transform(), viewport_rect); // The child render pass is just a green box. static const SkColor kCSSGreen = 0xff008000; scoped_ptr green = SolidColorDrawQuad::Create(); - green->SetNew(child_pass_shared_state.get(), - viewport_rect, - viewport_rect, - kCSSGreen, - false); + green->SetNew( + child_pass_shared_state, viewport_rect, viewport_rect, kCSSGreen, false); child_pass->quad_list.push_back(green.PassAs()); // Make a mask. @@ -1289,7 +1276,7 @@ TYPED_TEST(RendererPixelTest, RenderPassAndMaskWithPartialQuad) { // Set up a mask on the RenderPassDrawQuad. scoped_ptr mask_quad = RenderPassDrawQuad::Create(); - mask_quad->SetNew(root_pass_shared_state.get(), + mask_quad->SetNew(root_pass_shared_state, sub_rect, sub_rect, child_pass_id, @@ -1303,7 +1290,7 @@ TYPED_TEST(RendererPixelTest, RenderPassAndMaskWithPartialQuad) { // White background behind the masked render pass. scoped_ptr white = SolidColorDrawQuad::Create(); - white->SetNew(root_pass_shared_state.get(), + white->SetNew(root_pass_shared_state, viewport_rect, viewport_rect, SK_ColorWHITE, @@ -1343,27 +1330,28 @@ class RendererPixelTestWithBackgroundFilter // A non-visible quad in the filtering render pass. { - scoped_ptr shared_state = - CreateTestSharedQuadState(identity_content_to_target_transform, + SharedQuadState* shared_state = + CreateTestSharedQuadState(filter_pass.get(), + identity_content_to_target_transform, filter_pass_content_rect_); scoped_ptr color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew(shared_state.get(), + 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()); - filter_pass->shared_quad_state_list.push_back(shared_state.Pass()); } { - scoped_ptr shared_state = - CreateTestSharedQuadState(filter_pass_to_target_transform_, + SharedQuadState* shared_state = + CreateTestSharedQuadState(filter_pass.get(), + filter_pass_to_target_transform_, filter_pass_content_rect_); scoped_ptr filter_pass_quad = RenderPassDrawQuad::Create(); filter_pass_quad->SetNew( - shared_state.get(), + shared_state, filter_pass_content_rect_, filter_pass_content_rect_, filter_pass_id, @@ -1374,62 +1362,55 @@ class RendererPixelTestWithBackgroundFilter FilterOperations(), // filters this->background_filters_); root_pass->quad_list.push_back(filter_pass_quad.PassAs()); - root_pass->shared_quad_state_list.push_back(shared_state.Pass()); } const int kColumnWidth = device_viewport_rect.width() / 3; gfx::Rect left_rect = gfx::Rect(0, 0, kColumnWidth, 20); for (int i = 0; left_rect.y() < device_viewport_rect.height(); ++i) { - scoped_ptr shared_state = - CreateTestSharedQuadState(identity_content_to_target_transform, - left_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + root_pass.get(), identity_content_to_target_transform, left_rect); scoped_ptr color_quad = SolidColorDrawQuad::Create(); color_quad->SetNew( - shared_state.get(), left_rect, left_rect, SK_ColorGREEN, false); + shared_state, left_rect, left_rect, SK_ColorGREEN, false); root_pass->quad_list.push_back(color_quad.PassAs()); - root_pass->shared_quad_state_list.push_back(shared_state.Pass()); 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) { - scoped_ptr shared_state = - CreateTestSharedQuadState(identity_content_to_target_transform, - middle_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + root_pass.get(), identity_content_to_target_transform, middle_rect); scoped_ptr color_quad = SolidColorDrawQuad::Create(); color_quad->SetNew( - shared_state.get(), middle_rect, middle_rect, SK_ColorRED, false); + shared_state, middle_rect, middle_rect, SK_ColorRED, false); root_pass->quad_list.push_back(color_quad.PassAs()); - root_pass->shared_quad_state_list.push_back(shared_state.Pass()); 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) { - scoped_ptr shared_state = - CreateTestSharedQuadState(identity_content_to_target_transform, - right_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + root_pass.get(), identity_content_to_target_transform, right_rect); scoped_ptr color_quad = SolidColorDrawQuad::Create(); color_quad->SetNew( - shared_state.get(), right_rect, right_rect, SK_ColorBLUE, false); + shared_state, right_rect, right_rect, SK_ColorBLUE, false); root_pass->quad_list.push_back(color_quad.PassAs()); - root_pass->shared_quad_state_list.push_back(shared_state.Pass()); right_rect += gfx::Vector2d(0, right_rect.height() + 1); } - scoped_ptr shared_state = - CreateTestSharedQuadState(identity_content_to_target_transform, + SharedQuadState* shared_state = + CreateTestSharedQuadState(root_pass.get(), + identity_content_to_target_transform, device_viewport_rect); scoped_ptr background_quad = SolidColorDrawQuad::Create(); - background_quad->SetNew(shared_state.get(), + background_quad->SetNew(shared_state, device_viewport_rect, device_viewport_rect, SK_ColorWHITE, false); root_pass->quad_list.push_back(background_quad.PassAs()); - root_pass->shared_quad_state_list.push_back(shared_state.Pass()); pass_list_.push_back(filter_pass.Pass()); pass_list_.push_back(root_pass.Pass()); @@ -1506,10 +1487,10 @@ TEST_F(ExternalStencilPixelTest, StencilTestEnabled) { gfx::Rect rect(this->device_viewport_size_); RenderPass::Id id(1, 1); scoped_ptr pass = CreateTestRootRenderPass(id, rect); - scoped_ptr blue_shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* blue_shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr blue = SolidColorDrawQuad::Create(); - blue->SetNew(blue_shared_state.get(), rect, rect, SK_ColorBLUE, false); + blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false); pass->quad_list.push_back(blue.PassAs()); pass->has_transparent_background = false; RenderPassList pass_list; @@ -1529,10 +1510,10 @@ TEST_F(ExternalStencilPixelTest, StencilTestDisabled) { gfx::Rect rect(this->device_viewport_size_); RenderPass::Id id(1, 1); scoped_ptr pass = CreateTestRootRenderPass(id, rect); - scoped_ptr green_shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* green_shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr green = SolidColorDrawQuad::Create(); - green->SetNew(green_shared_state.get(), rect, rect, SK_ColorGREEN, false); + green->SetNew(green_shared_state, rect, rect, SK_ColorGREEN, false); pass->quad_list.push_back(green.PassAs()); RenderPassList pass_list; pass_list.push_back(pass.Pass()); @@ -1563,23 +1544,21 @@ TEST_F(ExternalStencilPixelTest, RenderSurfacesIgnoreStencil) { CreateTestRenderPass(child_pass_id, pass_rect, transform_to_root); gfx::Transform content_to_target_transform; - scoped_ptr shared_state = - CreateTestSharedQuadState(content_to_target_transform, viewport_rect); + SharedQuadState* shared_state = CreateTestSharedQuadState( + child_pass.get(), content_to_target_transform, viewport_rect); gfx::Rect blue_rect(0, 0, this->device_viewport_size_.width(), this->device_viewport_size_.height()); scoped_ptr blue = SolidColorDrawQuad::Create(); - blue->SetNew(shared_state.get(), blue_rect, blue_rect, SK_ColorBLUE, false); + blue->SetNew(shared_state, blue_rect, blue_rect, SK_ColorBLUE, false); child_pass->quad_list.push_back(blue.PassAs()); - scoped_ptr pass_shared_state = - CreateTestSharedQuadState(gfx::Transform(), pass_rect); - root_pass->quad_list.push_back( - CreateTestRenderPassDrawQuad(pass_shared_state.get(), - pass_rect, - child_pass_id)); + 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)); RenderPassList pass_list; pass_list.push_back(child_pass.Pass()); pass_list.push_back(root_pass.Pass()); @@ -1600,10 +1579,10 @@ TEST_F(ExternalStencilPixelTest, DeviceClip) { gfx::Rect rect(this->device_viewport_size_); RenderPass::Id id(1, 1); scoped_ptr pass = CreateTestRootRenderPass(id, rect); - scoped_ptr blue_shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* blue_shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr blue = SolidColorDrawQuad::Create(); - blue->SetNew(blue_shared_state.get(), rect, rect, SK_ColorBLUE, false); + blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false); pass->quad_list.push_back(blue.PassAs()); RenderPassList pass_list; pass_list.push_back(pass.Pass()); @@ -1623,30 +1602,30 @@ TEST_F(GLRendererPixelTest, AntiAliasing) { gfx::Transform red_content_to_target_transform; red_content_to_target_transform.Rotate(10); - scoped_ptr red_shared_state = - CreateTestSharedQuadState(red_content_to_target_transform, rect); + SharedQuadState* red_shared_state = CreateTestSharedQuadState( + pass.get(), red_content_to_target_transform, rect); scoped_ptr red = SolidColorDrawQuad::Create(); - red->SetNew(red_shared_state.get(), rect, rect, SK_ColorRED, false); + red->SetNew(red_shared_state, rect, rect, SK_ColorRED, false); pass->quad_list.push_back(red.PassAs()); gfx::Transform yellow_content_to_target_transform; yellow_content_to_target_transform.Rotate(5); - scoped_ptr yellow_shared_state = - CreateTestSharedQuadState(yellow_content_to_target_transform, rect); + SharedQuadState* yellow_shared_state = CreateTestSharedQuadState( + pass.get(), yellow_content_to_target_transform, rect); scoped_ptr yellow = SolidColorDrawQuad::Create(); - yellow->SetNew(yellow_shared_state.get(), rect, rect, SK_ColorYELLOW, false); + yellow->SetNew(yellow_shared_state, rect, rect, SK_ColorYELLOW, false); pass->quad_list.push_back(yellow.PassAs()); gfx::Transform blue_content_to_target_transform; - scoped_ptr blue_shared_state = - CreateTestSharedQuadState(blue_content_to_target_transform, rect); + SharedQuadState* blue_shared_state = CreateTestSharedQuadState( + pass.get(), blue_content_to_target_transform, rect); scoped_ptr blue = SolidColorDrawQuad::Create(); - blue->SetNew(blue_shared_state.get(), rect, rect, SK_ColorBLUE, false); + blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false); pass->quad_list.push_back(blue.PassAs()); @@ -1674,31 +1653,31 @@ TEST_F(GLRendererPixelTest, AxisAligned) { red_content_to_target_transform.Scale( 0.5f + 1.0f / (rect.width() * 2.0f), 0.5f + 1.0f / (rect.height() * 2.0f)); - scoped_ptr red_shared_state = - CreateTestSharedQuadState(red_content_to_target_transform, rect); + SharedQuadState* red_shared_state = CreateTestSharedQuadState( + pass.get(), red_content_to_target_transform, rect); scoped_ptr red = SolidColorDrawQuad::Create(); - red->SetNew(red_shared_state.get(), rect, rect, SK_ColorRED, false); + red->SetNew(red_shared_state, rect, rect, SK_ColorRED, false); pass->quad_list.push_back(red.PassAs()); 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); - scoped_ptr yellow_shared_state = - CreateTestSharedQuadState(yellow_content_to_target_transform, rect); + SharedQuadState* yellow_shared_state = CreateTestSharedQuadState( + pass.get(), yellow_content_to_target_transform, rect); scoped_ptr yellow = SolidColorDrawQuad::Create(); - yellow->SetNew(yellow_shared_state.get(), rect, rect, SK_ColorYELLOW, false); + yellow->SetNew(yellow_shared_state, rect, rect, SK_ColorYELLOW, false); pass->quad_list.push_back(yellow.PassAs()); gfx::Transform blue_content_to_target_transform; - scoped_ptr blue_shared_state = - CreateTestSharedQuadState(blue_content_to_target_transform, rect); + SharedQuadState* blue_shared_state = CreateTestSharedQuadState( + pass.get(), blue_content_to_target_transform, rect); scoped_ptr blue = SolidColorDrawQuad::Create(); - blue->SetNew(blue_shared_state.get(), rect, rect, SK_ColorBLUE, false); + blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false); pass->quad_list.push_back(blue.PassAs()); @@ -1726,20 +1705,20 @@ TEST_F(GLRendererPixelTest, ForceAntiAliasingOff) { hole_content_to_target_transform.Scale( 0.5f + 1.0f / (rect.width() * 2.0f), 0.5f + 1.0f / (rect.height() * 2.0f)); - scoped_ptr hole_shared_state = - CreateTestSharedQuadState(hole_content_to_target_transform, rect); + SharedQuadState* hole_shared_state = CreateTestSharedQuadState( + pass.get(), hole_content_to_target_transform, rect); scoped_ptr hole = SolidColorDrawQuad::Create(); - hole->SetAll(hole_shared_state.get(), rect, rect, rect, false, - SK_ColorTRANSPARENT, true); + hole->SetAll( + hole_shared_state, rect, rect, rect, false, SK_ColorTRANSPARENT, true); pass->quad_list.push_back(hole.PassAs()); gfx::Transform green_content_to_target_transform; - scoped_ptr green_shared_state = - CreateTestSharedQuadState(green_content_to_target_transform, rect); + SharedQuadState* green_shared_state = CreateTestSharedQuadState( + pass.get(), green_content_to_target_transform, rect); scoped_ptr green = SolidColorDrawQuad::Create(); - green->SetNew(green_shared_state.get(), rect, rect, SK_ColorGREEN, false); + green->SetNew(green_shared_state, rect, rect, SK_ColorGREEN, false); pass->quad_list.push_back(green.PassAs()); @@ -1764,24 +1743,24 @@ TEST_F(GLRendererPixelTest, AntiAliasingPerspective) { 0.0f, 0.3528f, 5.9737f, 9.5f, 0.0f, -0.2250f, -0.9744f, 0.0f, 0.0f, 0.0225f, 0.0974f, 1.0f); - scoped_ptr red_shared_state = - CreateTestSharedQuadState(red_content_to_target_transform, red_rect); + SharedQuadState* red_shared_state = CreateTestSharedQuadState( + pass.get(), red_content_to_target_transform, red_rect); scoped_ptr red = SolidColorDrawQuad::Create(); - red->SetNew(red_shared_state.get(), red_rect, red_rect, SK_ColorRED, false); + red->SetNew(red_shared_state, red_rect, red_rect, SK_ColorRED, false); pass->quad_list.push_back(red.PassAs()); gfx::Rect green_rect(19, 7, 180, 10); - scoped_ptr green_shared_state = - CreateTestSharedQuadState(gfx::Transform(), green_rect); + SharedQuadState* green_shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), green_rect); scoped_ptr green = SolidColorDrawQuad::Create(); green->SetNew( - green_shared_state.get(), green_rect, green_rect, SK_ColorGREEN, false); + green_shared_state, green_rect, green_rect, SK_ColorGREEN, false); pass->quad_list.push_back(green.PassAs()); - scoped_ptr blue_shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* blue_shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); scoped_ptr blue = SolidColorDrawQuad::Create(); - blue->SetNew(blue_shared_state.get(), rect, rect, SK_ColorBLUE, false); + blue->SetNew(blue_shared_state, rect, rect, SK_ColorBLUE, false); pass->quad_list.push_back(blue.PassAs()); RenderPassList pass_list; @@ -1823,14 +1802,15 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadIdentityScale) { blue_content_to_target_transform.Translate(offset.x(), offset.y()); gfx::RectF blue_scissor_rect = blue_clip_rect; blue_content_to_target_transform.TransformRect(&blue_scissor_rect); - scoped_ptr blue_shared_state = - CreateTestSharedQuadStateClipped(blue_content_to_target_transform, + SharedQuadState* blue_shared_state = + CreateTestSharedQuadStateClipped(pass.get(), + blue_content_to_target_transform, blue_rect, gfx::ToEnclosingRect(blue_scissor_rect)); scoped_ptr blue_quad = PictureDrawQuad::Create(); - blue_quad->SetNew(blue_shared_state.get(), + blue_quad->SetNew(blue_shared_state, viewport, // Intentionally bigger than clip. gfx::Rect(), viewport, @@ -1851,11 +1831,11 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadIdentityScale) { green_pile->RerecordPile(); gfx::Transform green_content_to_target_transform; - scoped_ptr green_shared_state = - CreateTestSharedQuadState(green_content_to_target_transform, viewport); + SharedQuadState* green_shared_state = CreateTestSharedQuadState( + pass.get(), green_content_to_target_transform, viewport); scoped_ptr green_quad = PictureDrawQuad::Create(); - green_quad->SetNew(green_shared_state.get(), + green_quad->SetNew(green_shared_state, viewport, gfx::Rect(), viewport, @@ -1896,12 +1876,12 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadOpacity) { green_pile->RerecordPile(); gfx::Transform green_content_to_target_transform; - scoped_ptr green_shared_state = - CreateTestSharedQuadState(green_content_to_target_transform, viewport); + SharedQuadState* green_shared_state = CreateTestSharedQuadState( + pass.get(), green_content_to_target_transform, viewport); green_shared_state->opacity = 0.5f; scoped_ptr green_quad = PictureDrawQuad::Create(); - green_quad->SetNew(green_shared_state.get(), + green_quad->SetNew(green_shared_state, viewport, gfx::Rect(), viewport, @@ -1922,11 +1902,11 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadOpacity) { white_pile->RerecordPile(); gfx::Transform white_content_to_target_transform; - scoped_ptr white_shared_state = - CreateTestSharedQuadState(white_content_to_target_transform, viewport); + SharedQuadState* white_shared_state = CreateTestSharedQuadState( + pass.get(), white_content_to_target_transform, viewport); scoped_ptr white_quad = PictureDrawQuad::Create(); - white_quad->SetNew(white_shared_state.get(), + white_quad->SetNew(white_shared_state, viewport, gfx::Rect(), viewport, @@ -1997,11 +1977,11 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadDisableImageFiltering) { pile->RerecordPile(); gfx::Transform content_to_target_transform; - scoped_ptr shared_state = - CreateTestSharedQuadState(content_to_target_transform, viewport); + SharedQuadState* shared_state = CreateTestSharedQuadState( + pass.get(), content_to_target_transform, viewport); scoped_ptr quad = PictureDrawQuad::Create(); - quad->SetNew(shared_state.get(), + quad->SetNew(shared_state, viewport, gfx::Rect(), viewport, @@ -2053,11 +2033,12 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) { green_pile->add_draw_rect_with_paint(green_rect2, green_paint); green_pile->RerecordPile(); - scoped_ptr top_right_green_shared_quad_state = - CreateTestSharedQuadState(green_content_to_target_transform, viewport); + SharedQuadState* top_right_green_shared_quad_state = + CreateTestSharedQuadState( + pass.get(), green_content_to_target_transform, viewport); scoped_ptr green_quad1 = PictureDrawQuad::Create(); - green_quad1->SetNew(top_right_green_shared_quad_state.get(), + green_quad1->SetNew(top_right_green_shared_quad_state, green_rect1, gfx::Rect(), green_rect1, @@ -2070,7 +2051,7 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) { pass->quad_list.push_back(green_quad1.PassAs()); scoped_ptr green_quad2 = PictureDrawQuad::Create(); - green_quad2->SetNew(top_right_green_shared_quad_state.get(), + green_quad2->SetNew(top_right_green_shared_quad_state, green_rect2, gfx::Rect(), green_rect2, @@ -2087,12 +2068,14 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) { gfx::Rect bottom_right_rect( gfx::Point(viewport.width() / 2, viewport.height() / 2), gfx::Size(viewport.width() / 2, viewport.height() / 2)); - scoped_ptr bottom_right_green_shared_state = - CreateTestSharedQuadStateClipped( - green_content_to_target_transform, viewport, bottom_right_rect); + SharedQuadState* bottom_right_green_shared_state = + CreateTestSharedQuadStateClipped(pass.get(), + green_content_to_target_transform, + viewport, + bottom_right_rect); scoped_ptr bottom_right_color_quad = SolidColorDrawQuad::Create(); - bottom_right_color_quad->SetNew(bottom_right_green_shared_state.get(), + bottom_right_color_quad->SetNew(bottom_right_green_shared_state, viewport, viewport, SK_ColorGREEN, @@ -2141,11 +2124,11 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) { gfx::Transform content_to_target_transform; content_to_target_transform.Scale(10.0, 10.0); gfx::Rect quad_content_rect(gfx::Size(20, 20)); - scoped_ptr blue_shared_state = - CreateTestSharedQuadState(content_to_target_transform, quad_content_rect); + SharedQuadState* blue_shared_state = CreateTestSharedQuadState( + pass.get(), content_to_target_transform, quad_content_rect); scoped_ptr blue_quad = PictureDrawQuad::Create(); - blue_quad->SetNew(blue_shared_state.get(), + blue_quad->SetNew(blue_shared_state, quad_content_rect, gfx::Rect(), quad_content_rect, @@ -2160,11 +2143,10 @@ TYPED_TEST(RendererPixelTest, PictureDrawQuadNonIdentityScale) { // 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())); - scoped_ptr half_green_shared_state = - CreateTestSharedQuadState(half_green_content_to_target_transform, - half_green_rect); + SharedQuadState* half_green_shared_state = CreateTestSharedQuadState( + pass.get(), half_green_content_to_target_transform, half_green_rect); scoped_ptr half_color_quad = SolidColorDrawQuad::Create(); - half_color_quad->SetNew(half_green_shared_state.get(), + half_color_quad->SetNew(half_green_shared_state, half_green_rect, half_green_rect, SK_ColorGREEN, @@ -2186,8 +2168,8 @@ TYPED_TEST(RendererPixelTest, WrapModeRepeat) { RenderPass::Id id(1, 1); scoped_ptr pass = CreateTestRootRenderPass(id, rect); - scoped_ptr shared_state = - CreateTestSharedQuadState(gfx::Transform(), rect); + SharedQuadState* shared_state = + CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect); gfx::Rect texture_rect(4, 4); SkPMColor colors[4] = { @@ -2218,7 +2200,7 @@ TYPED_TEST(RendererPixelTest, WrapModeRepeat) { float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f}; scoped_ptr texture_quad = TextureDrawQuad::Create(); texture_quad->SetNew( - shared_state.get(), + shared_state, gfx::Rect(this->device_viewport_size_), gfx::Rect(), gfx::Rect(this->device_viewport_size_), diff --git a/cc/output/software_renderer_unittest.cc b/cc/output/software_renderer_unittest.cc index 2fd6c6d5a3de..af4343b42c58 100644 --- a/cc/output/software_renderer_unittest.cc +++ b/cc/output/software_renderer_unittest.cc @@ -68,7 +68,12 @@ TEST_F(SoftwareRendererTest, SolidColorQuad) { InitializeRenderer(make_scoped_ptr(new SoftwareOutputDevice)); - scoped_ptr shared_quad_state = SharedQuadState::Create(); + RenderPass::Id root_render_pass_id = RenderPass::Id(1, 1); + scoped_ptr root_render_pass = TestRenderPass::Create(); + root_render_pass->SetNew( + root_render_pass_id, outer_rect, outer_rect, gfx::Transform()); + SharedQuadState* shared_quad_state = + root_render_pass->CreateAndAppendSharedQuadState(); shared_quad_state->SetAll(gfx::Transform(), outer_size, outer_rect, @@ -76,16 +81,12 @@ TEST_F(SoftwareRendererTest, SolidColorQuad) { false, 1.0, SkXfermode::kSrcOver_Mode); - RenderPass::Id root_render_pass_id = RenderPass::Id(1, 1); - scoped_ptr root_render_pass = TestRenderPass::Create(); - root_render_pass->SetNew( - root_render_pass_id, outer_rect, outer_rect, gfx::Transform()); scoped_ptr outer_quad = SolidColorDrawQuad::Create(); outer_quad->SetNew( - shared_quad_state.get(), outer_rect, outer_rect, SK_ColorYELLOW, false); + shared_quad_state, outer_rect, outer_rect, SK_ColorYELLOW, false); scoped_ptr inner_quad = SolidColorDrawQuad::Create(); inner_quad->SetNew( - shared_quad_state.get(), inner_rect, inner_rect, SK_ColorCYAN, false); + shared_quad_state, inner_rect, inner_rect, SK_ColorCYAN, false); inner_quad->visible_rect = visible_rect; root_render_pass->AppendQuad(inner_quad.PassAs()); root_render_pass->AppendQuad(outer_quad.PassAs()); @@ -160,7 +161,12 @@ TEST_F(SoftwareRendererTest, TileQuad) { gfx::Rect root_rect = outer_rect; - scoped_ptr shared_quad_state = SharedQuadState::Create(); + RenderPass::Id root_render_pass_id = RenderPass::Id(1, 1); + scoped_ptr root_render_pass = TestRenderPass::Create(); + root_render_pass->SetNew( + root_render_pass_id, root_rect, root_rect, gfx::Transform()); + SharedQuadState* shared_quad_state = + root_render_pass->CreateAndAppendSharedQuadState(); shared_quad_state->SetAll(gfx::Transform(), outer_size, outer_rect, @@ -168,12 +174,8 @@ TEST_F(SoftwareRendererTest, TileQuad) { false, 1.0, SkXfermode::kSrcOver_Mode); - RenderPass::Id root_render_pass_id = RenderPass::Id(1, 1); - scoped_ptr root_render_pass = TestRenderPass::Create(); - root_render_pass->SetNew( - root_render_pass_id, root_rect, root_rect, gfx::Transform()); scoped_ptr outer_quad = TileDrawQuad::Create(); - outer_quad->SetNew(shared_quad_state.get(), + outer_quad->SetNew(shared_quad_state, outer_rect, outer_rect, outer_rect, @@ -182,7 +184,7 @@ TEST_F(SoftwareRendererTest, TileQuad) { outer_size, false); scoped_ptr inner_quad = TileDrawQuad::Create(); - inner_quad->SetNew(shared_quad_state.get(), + inner_quad->SetNew(shared_quad_state, inner_rect, inner_rect, inner_rect, @@ -249,7 +251,12 @@ TEST_F(SoftwareRendererTest, TileQuadVisibleRect) { gfx::Rect root_rect(tile_size); - scoped_ptr shared_quad_state = SharedQuadState::Create(); + RenderPass::Id root_render_pass_id = RenderPass::Id(1, 1); + scoped_ptr root_render_pass = TestRenderPass::Create(); + root_render_pass->SetNew( + root_render_pass_id, root_rect, root_rect, gfx::Transform()); + SharedQuadState* shared_quad_state = + root_render_pass->CreateAndAppendSharedQuadState(); shared_quad_state->SetAll(gfx::Transform(), tile_size, tile_rect, @@ -257,12 +264,8 @@ TEST_F(SoftwareRendererTest, TileQuadVisibleRect) { false, 1.0, SkXfermode::kSrcOver_Mode); - RenderPass::Id root_render_pass_id = RenderPass::Id(1, 1); - scoped_ptr root_render_pass = TestRenderPass::Create(); - root_render_pass->SetNew( - root_render_pass_id, root_rect, root_rect, gfx::Transform()); scoped_ptr quad = TileDrawQuad::Create(); - quad->SetNew(shared_quad_state.get(), + quad->SetNew(shared_quad_state, tile_rect, tile_rect, tile_rect, diff --git a/cc/quads/render_pass_unittest.cc b/cc/quads/render_pass_unittest.cc index f714dbee738f..7f723a406072 100644 --- a/cc/quads/render_pass_unittest.cc +++ b/cc/quads/render_pass_unittest.cc @@ -79,7 +79,7 @@ TEST(RenderPassTest, CopyShouldBeIdenticalExceptIdAndQuads) { pass->copy_requests.push_back(CopyOutputRequest::CreateEmptyRequest()); // Stick a quad in the pass, this should not get copied. - scoped_ptr shared_state = SharedQuadState::Create(); + SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState(); shared_state->SetAll(gfx::Transform(), gfx::Size(), gfx::Rect(), @@ -87,7 +87,6 @@ TEST(RenderPassTest, CopyShouldBeIdenticalExceptIdAndQuads) { false, 1, SkXfermode::kSrcOver_Mode); - pass->AppendSharedQuadState(shared_state.Pass()); scoped_ptr checkerboard_quad = CheckerboardDrawQuad::Create(); @@ -130,7 +129,7 @@ TEST(RenderPassTest, CopyAllShouldBeIdentical) { has_transparent_background); // Two quads using one shared state. - scoped_ptr shared_state1 = SharedQuadState::Create(); + SharedQuadState* shared_state1 = pass->CreateAndAppendSharedQuadState(); shared_state1->SetAll(gfx::Transform(), gfx::Size(1, 1), gfx::Rect(), @@ -138,7 +137,6 @@ TEST(RenderPassTest, CopyAllShouldBeIdentical) { false, 1, SkXfermode::kSrcOver_Mode); - pass->AppendSharedQuadState(shared_state1.Pass()); scoped_ptr checkerboard_quad1 = CheckerboardDrawQuad::Create(); @@ -157,7 +155,7 @@ TEST(RenderPassTest, CopyAllShouldBeIdentical) { pass->quad_list.push_back(checkerboard_quad2.PassAs()); // And two quads using another shared state. - scoped_ptr shared_state2 = SharedQuadState::Create(); + SharedQuadState* shared_state2 = pass->CreateAndAppendSharedQuadState(); shared_state2->SetAll(gfx::Transform(), gfx::Size(2, 2), gfx::Rect(), @@ -165,7 +163,6 @@ TEST(RenderPassTest, CopyAllShouldBeIdentical) { false, 1, SkXfermode::kSrcOver_Mode); - pass->AppendSharedQuadState(shared_state2.Pass()); scoped_ptr checkerboard_quad3 = CheckerboardDrawQuad::Create(); @@ -198,7 +195,8 @@ TEST(RenderPassTest, CopyAllShouldBeIdentical) { contrib_transform_to_root, contrib_has_transparent_background); - scoped_ptr contrib_shared_state = SharedQuadState::Create(); + SharedQuadState* contrib_shared_state = + contrib->CreateAndAppendSharedQuadState(); contrib_shared_state->SetAll(gfx::Transform(), gfx::Size(2, 2), gfx::Rect(), @@ -206,7 +204,6 @@ TEST(RenderPassTest, CopyAllShouldBeIdentical) { false, 1, SkXfermode::kSrcOver_Mode); - contrib->AppendSharedQuadState(contrib_shared_state.Pass()); scoped_ptr contrib_quad = CheckerboardDrawQuad::Create(); @@ -258,7 +255,7 @@ TEST(RenderPassTest, CopyAllWithCulledQuads) { has_transparent_background); // A shared state with a quad. - scoped_ptr shared_state1 = SharedQuadState::Create(); + SharedQuadState* shared_state1 = pass->CreateAndAppendSharedQuadState(); shared_state1->SetAll(gfx::Transform(), gfx::Size(1, 1), gfx::Rect(), @@ -266,7 +263,6 @@ TEST(RenderPassTest, CopyAllWithCulledQuads) { false, 1, SkXfermode::kSrcOver_Mode); - pass->AppendSharedQuadState(shared_state1.Pass()); scoped_ptr checkerboard_quad1 = CheckerboardDrawQuad::Create(); @@ -277,7 +273,7 @@ TEST(RenderPassTest, CopyAllWithCulledQuads) { pass->quad_list.push_back(checkerboard_quad1.PassAs()); // A shared state with no quads, they were culled. - scoped_ptr shared_state2 = SharedQuadState::Create(); + SharedQuadState* shared_state2 = pass->CreateAndAppendSharedQuadState(); shared_state2->SetAll(gfx::Transform(), gfx::Size(2, 2), gfx::Rect(), @@ -285,10 +281,9 @@ TEST(RenderPassTest, CopyAllWithCulledQuads) { false, 1, SkXfermode::kSrcOver_Mode); - pass->AppendSharedQuadState(shared_state2.Pass()); // A second shared state with no quads. - scoped_ptr shared_state3 = SharedQuadState::Create(); + SharedQuadState* shared_state3 = pass->CreateAndAppendSharedQuadState(); shared_state3->SetAll(gfx::Transform(), gfx::Size(2, 2), gfx::Rect(), @@ -296,10 +291,9 @@ TEST(RenderPassTest, CopyAllWithCulledQuads) { false, 1, SkXfermode::kSrcOver_Mode); - pass->AppendSharedQuadState(shared_state3.Pass()); // A last shared state with a quad again. - scoped_ptr shared_state4 = SharedQuadState::Create(); + SharedQuadState* shared_state4 = pass->CreateAndAppendSharedQuadState(); shared_state4->SetAll(gfx::Transform(), gfx::Size(2, 2), gfx::Rect(), @@ -307,7 +301,6 @@ TEST(RenderPassTest, CopyAllWithCulledQuads) { false, 1, SkXfermode::kSrcOver_Mode); - pass->AppendSharedQuadState(shared_state4.Pass()); scoped_ptr checkerboard_quad2 = CheckerboardDrawQuad::Create(); diff --git a/cc/surfaces/surface_aggregator_test_helpers.cc b/cc/surfaces/surface_aggregator_test_helpers.cc index be6340ec18f6..6706c507a596 100644 --- a/cc/surfaces/surface_aggregator_test_helpers.cc +++ b/cc/surfaces/surface_aggregator_test_helpers.cc @@ -34,7 +34,7 @@ void AddTestSurfaceQuad(TestRenderPass* pass, float opacity = 1.0; SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode; - scoped_ptr shared_quad_state = SharedQuadState::Create(); + SharedQuadState* shared_quad_state = pass->CreateAndAppendSharedQuadState(); shared_quad_state->SetAll(content_to_target_transform, content_bounds, visible_content_rect, @@ -42,7 +42,6 @@ void AddTestSurfaceQuad(TestRenderPass* pass, is_clipped, opacity, blend_mode); - pass->shared_quad_state_list.push_back(shared_quad_state.Pass()); scoped_ptr surface_quad = SurfaceDrawQuad::Create(); gfx::Rect quad_rect = gfx::Rect(surface_size); diff --git a/cc/surfaces/surface_aggregator_unittest.cc b/cc/surfaces/surface_aggregator_unittest.cc index 3f2fbd816589..1809409bef4a 100644 --- a/cc/surfaces/surface_aggregator_unittest.cc +++ b/cc/surfaces/surface_aggregator_unittest.cc @@ -418,7 +418,7 @@ void AddSolidColorQuadWithBlendMode(const gfx::Size& size, float opacity = 1.f; bool force_anti_aliasing_off = false; - scoped_ptr sqs = SharedQuadState::Create(); + SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState(); sqs->SetAll(content_to_target_transform, content_bounds, visible_content_rect, @@ -426,7 +426,6 @@ void AddSolidColorQuadWithBlendMode(const gfx::Size& size, is_clipped, opacity, blend_mode); - pass->shared_quad_state_list.push_back(sqs.Pass()); scoped_ptr color_quad = SolidColorDrawQuad::Create(); color_quad->SetNew(pass->shared_quad_state_list.back(), diff --git a/cc/surfaces/surfaces_pixeltest.cc b/cc/surfaces/surfaces_pixeltest.cc index abcc532e1aed..3559d531a201 100644 --- a/cc/surfaces/surfaces_pixeltest.cc +++ b/cc/surfaces/surfaces_pixeltest.cc @@ -23,7 +23,8 @@ class SurfacesPixelTest : public RendererPixelTest { SurfaceManager manager_; }; -scoped_ptr CreateTestSharedQuadState( +SharedQuadState* CreateAndAppendTestSharedQuadState( + RenderPass* render_pass, const gfx::Transform& transform, const gfx::Size& size) { const gfx::Size content_bounds = size; @@ -32,7 +33,7 @@ scoped_ptr CreateTestSharedQuadState( bool is_clipped = false; float opacity = 1.f; const SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode; - scoped_ptr shared_state = SharedQuadState::Create(); + SharedQuadState* shared_state = render_pass->CreateAndAppendSharedQuadState(); shared_state->SetAll(transform, content_bounds, visible_content_rect, @@ -40,7 +41,7 @@ scoped_ptr CreateTestSharedQuadState( is_clipped, opacity, blend_mode); - return shared_state.Pass(); + return shared_state; } // Draws a very simple frame with no surface references. @@ -50,8 +51,8 @@ TEST_F(SurfacesPixelTest, DrawSimpleFrame) { scoped_ptr pass = RenderPass::Create(); pass->SetNew(id, rect, rect, gfx::Transform()); - pass->shared_quad_state_list.push_back( - CreateTestSharedQuadState(gfx::Transform(), device_viewport_size_)); + CreateAndAppendTestSharedQuadState( + pass.get(), gfx::Transform(), device_viewport_size_); scoped_ptr color_quad = SolidColorDrawQuad::Create(); bool force_anti_aliasing_off = false; @@ -96,8 +97,8 @@ TEST_F(SurfacesPixelTest, DrawSimpleAggregatedFrame) { scoped_ptr pass = RenderPass::Create(); pass->SetNew(id, rect, rect, gfx::Transform()); - pass->shared_quad_state_list.push_back( - CreateTestSharedQuadState(gfx::Transform(), device_viewport_size_)); + CreateAndAppendTestSharedQuadState( + pass.get(), gfx::Transform(), device_viewport_size_); scoped_ptr surface_quad = SurfaceDrawQuad::Create(); surface_quad->SetNew(pass->shared_quad_state_list.back(), @@ -130,8 +131,8 @@ TEST_F(SurfacesPixelTest, DrawSimpleAggregatedFrame) { scoped_ptr pass = RenderPass::Create(); pass->SetNew(id, rect, rect, gfx::Transform()); - pass->shared_quad_state_list.push_back( - CreateTestSharedQuadState(gfx::Transform(), child_size)); + CreateAndAppendTestSharedQuadState( + pass.get(), gfx::Transform(), child_size); scoped_ptr color_quad = SolidColorDrawQuad::Create(); bool force_anti_aliasing_off = false; @@ -186,8 +187,8 @@ TEST_F(SurfacesPixelTest, DrawAggregatedFrameWithSurfaceTransforms) { pass->SetNew(id, rect, rect, gfx::Transform()); gfx::Transform surface_transform; - pass->shared_quad_state_list.push_back( - CreateTestSharedQuadState(surface_transform, device_viewport_size_)); + CreateAndAppendTestSharedQuadState( + pass.get(), surface_transform, device_viewport_size_); scoped_ptr left_surface_quad = SurfaceDrawQuad::Create(); left_surface_quad->SetNew(pass->shared_quad_state_list.back(), @@ -197,8 +198,8 @@ TEST_F(SurfacesPixelTest, DrawAggregatedFrameWithSurfaceTransforms) { pass->quad_list.push_back(left_surface_quad.PassAs()); surface_transform.Translate(100, 0); - pass->shared_quad_state_list.push_back( - CreateTestSharedQuadState(surface_transform, device_viewport_size_)); + CreateAndAppendTestSharedQuadState( + pass.get(), surface_transform, device_viewport_size_); scoped_ptr right_surface_quad = SurfaceDrawQuad::Create(); right_surface_quad->SetNew(pass->shared_quad_state_list.back(), @@ -222,8 +223,8 @@ TEST_F(SurfacesPixelTest, DrawAggregatedFrameWithSurfaceTransforms) { scoped_ptr pass = RenderPass::Create(); pass->SetNew(id, rect, rect, gfx::Transform()); - pass->shared_quad_state_list.push_back( - CreateTestSharedQuadState(gfx::Transform(), child_size)); + CreateAndAppendTestSharedQuadState( + pass.get(), gfx::Transform(), child_size); scoped_ptr top_color_quad = SolidColorDrawQuad::Create(); @@ -259,8 +260,8 @@ TEST_F(SurfacesPixelTest, DrawAggregatedFrameWithSurfaceTransforms) { scoped_ptr pass = RenderPass::Create(); pass->SetNew(id, rect, rect, gfx::Transform()); - pass->shared_quad_state_list.push_back( - CreateTestSharedQuadState(gfx::Transform(), child_size)); + CreateAndAppendTestSharedQuadState( + pass.get(), gfx::Transform(), child_size); scoped_ptr top_color_quad = SolidColorDrawQuad::Create(); diff --git a/cc/test/render_pass_test_common.cc b/cc/test/render_pass_test_common.cc index a68e00bb4b72..dd58b43b2387 100644 --- a/cc/test/render_pass_test_common.cc +++ b/cc/test/render_pass_test_common.cc @@ -23,10 +23,6 @@ void TestRenderPass::AppendQuad(scoped_ptr quad) { quad_list.push_back(quad.Pass()); } -void TestRenderPass::AppendSharedQuadState(scoped_ptr state) { - shared_quad_state_list.push_back(state.Pass()); -} - void TestRenderPass::AppendOneOfEveryQuadType( ResourceProvider* resource_provider, RenderPass::Id child_pass) { @@ -77,7 +73,7 @@ void TestRenderPass::AppendOneOfEveryQuadType( resource_provider->best_texture_format()); resource_provider->AllocateForTesting(resource7); - scoped_ptr shared_state = SharedQuadState::Create(); + SharedQuadState* shared_state = this->CreateAndAppendSharedQuadState(); shared_state->SetAll(gfx::Transform(), rect.size(), rect, @@ -88,18 +84,16 @@ void TestRenderPass::AppendOneOfEveryQuadType( scoped_ptr checkerboard_quad = CheckerboardDrawQuad::Create(); - checkerboard_quad->SetNew( - shared_state.get(), rect, visible_rect, SK_ColorRED); + checkerboard_quad->SetNew(shared_state, rect, visible_rect, SK_ColorRED); AppendQuad(checkerboard_quad.PassAs()); scoped_ptr debug_border_quad = DebugBorderDrawQuad::Create(); - debug_border_quad->SetNew( - shared_state.get(), rect, visible_rect, SK_ColorRED, 1); + debug_border_quad->SetNew(shared_state, rect, visible_rect, SK_ColorRED, 1); AppendQuad(debug_border_quad.PassAs()); scoped_ptr io_surface_quad = IOSurfaceDrawQuad::Create(); - io_surface_quad->SetNew(shared_state.get(), + io_surface_quad->SetNew(shared_state, rect, opaque_rect, visible_rect, @@ -111,7 +105,7 @@ void TestRenderPass::AppendOneOfEveryQuadType( if (child_pass.layer_id) { scoped_ptr render_pass_quad = RenderPassDrawQuad::Create(); - render_pass_quad->SetNew(shared_state.get(), + render_pass_quad->SetNew(shared_state, rect, visible_rect, child_pass, @@ -125,7 +119,7 @@ void TestRenderPass::AppendOneOfEveryQuadType( scoped_ptr render_pass_replica_quad = RenderPassDrawQuad::Create(); - render_pass_replica_quad->SetNew(shared_state.get(), + render_pass_replica_quad->SetNew(shared_state, rect, visible_rect, child_pass, @@ -141,12 +135,12 @@ void TestRenderPass::AppendOneOfEveryQuadType( scoped_ptr solid_color_quad = SolidColorDrawQuad::Create(); solid_color_quad->SetNew( - shared_state.get(), rect, visible_rect, SK_ColorRED, false); + shared_state, rect, visible_rect, SK_ColorRED, false); AppendQuad(solid_color_quad.PassAs()); scoped_ptr stream_video_quad = StreamVideoDrawQuad::Create(); - stream_video_quad->SetNew(shared_state.get(), + stream_video_quad->SetNew(shared_state, rect, opaque_rect, visible_rect, @@ -155,7 +149,7 @@ void TestRenderPass::AppendOneOfEveryQuadType( AppendQuad(stream_video_quad.PassAs()); scoped_ptr texture_quad = TextureDrawQuad::Create(); - texture_quad->SetNew(shared_state.get(), + texture_quad->SetNew(shared_state, rect, opaque_rect, visible_rect, @@ -169,7 +163,7 @@ void TestRenderPass::AppendOneOfEveryQuadType( AppendQuad(texture_quad.PassAs()); scoped_ptr scaled_tile_quad = TileDrawQuad::Create(); - scaled_tile_quad->SetNew(shared_state.get(), + scaled_tile_quad->SetNew(shared_state, rect, opaque_rect, visible_rect, @@ -179,13 +173,14 @@ void TestRenderPass::AppendOneOfEveryQuadType( false); AppendQuad(scaled_tile_quad.PassAs()); - scoped_ptr transformed_state = shared_state->Copy(); + SharedQuadState* transformed_state = this->CreateAndAppendSharedQuadState(); + transformed_state->CopyFrom(shared_state); gfx::Transform rotation; rotation.Rotate(45); transformed_state->content_to_target_transform = transformed_state->content_to_target_transform * rotation; scoped_ptr transformed_tile_quad = TileDrawQuad::Create(); - transformed_tile_quad->SetNew(transformed_state.get(), + transformed_tile_quad->SetNew(transformed_state, rect, opaque_rect, visible_rect, @@ -195,7 +190,7 @@ void TestRenderPass::AppendOneOfEveryQuadType( false); AppendQuad(transformed_tile_quad.PassAs()); - scoped_ptr shared_state2 = SharedQuadState::Create(); + SharedQuadState* shared_state2 = this->CreateAndAppendSharedQuadState(); shared_state->SetAll(gfx::Transform(), rect.size(), rect, @@ -205,7 +200,7 @@ void TestRenderPass::AppendOneOfEveryQuadType( SkXfermode::kSrcOver_Mode); scoped_ptr tile_quad = TileDrawQuad::Create(); - tile_quad->SetNew(shared_state2.get(), + tile_quad->SetNew(shared_state2, rect, opaque_rect, visible_rect, @@ -227,7 +222,7 @@ void TestRenderPass::AppendOneOfEveryQuadType( } YUVVideoDrawQuad::ColorSpace color_space = YUVVideoDrawQuad::REC_601; scoped_ptr yuv_quad = YUVVideoDrawQuad::Create(); - yuv_quad->SetNew(shared_state2.get(), + yuv_quad->SetNew(shared_state2, rect, opaque_rect, visible_rect, @@ -238,10 +233,6 @@ void TestRenderPass::AppendOneOfEveryQuadType( plane_resources[3], color_space); AppendQuad(yuv_quad.PassAs()); - - AppendSharedQuadState(shared_state.Pass()); - AppendSharedQuadState(transformed_state.Pass()); - AppendSharedQuadState(shared_state2.Pass()); } } // namespace cc diff --git a/cc/test/render_pass_test_common.h b/cc/test/render_pass_test_common.h index 651278f3f2a4..24467edf52fc 100644 --- a/cc/test/render_pass_test_common.h +++ b/cc/test/render_pass_test_common.h @@ -20,7 +20,6 @@ class TestRenderPass : public RenderPass { } void AppendQuad(scoped_ptr quad); - void AppendSharedQuadState(scoped_ptr state); void AppendOneOfEveryQuadType(ResourceProvider* resource_provider, RenderPass::Id child_pass); diff --git a/cc/trees/layer_tree_host_unittest_delegated.cc b/cc/trees/layer_tree_host_unittest_delegated.cc index a6562ae0bb3b..02f8db32370f 100644 --- a/cc/trees/layer_tree_host_unittest_delegated.cc +++ b/cc/trees/layer_tree_host_unittest_delegated.cc @@ -99,7 +99,8 @@ class LayerTreeHostDelegatedTest : public LayerTreeTest { root_damage_rect, gfx::Transform()); - scoped_ptr shared_quad_state = SharedQuadState::Create(); + SharedQuadState* shared_quad_state = + root_pass->CreateAndAppendSharedQuadState(); gfx::Rect rect = root_output_rect; gfx::Rect opaque_rect = root_output_rect; @@ -114,7 +115,7 @@ class LayerTreeHostDelegatedTest : public LayerTreeTest { bool flipped = false; scoped_ptr invalid_draw_quad = TextureDrawQuad::Create(); - invalid_draw_quad->SetNew(shared_quad_state.get(), + invalid_draw_quad->SetNew(shared_quad_state, rect, opaque_rect, visible_rect, @@ -127,8 +128,6 @@ class LayerTreeHostDelegatedTest : public LayerTreeTest { flipped); root_pass->quad_list.push_back(invalid_draw_quad.PassAs()); - root_pass->shared_quad_state_list.push_back(shared_quad_state.Pass()); - frame->render_pass_list.push_back(root_pass.Pass()); return frame.Pass(); } @@ -148,10 +147,11 @@ class LayerTreeHostDelegatedTest : public LayerTreeTest { void AddTextureQuad(DelegatedFrameData* frame, ResourceProvider::ResourceId resource_id) { - scoped_ptr sqs = SharedQuadState::Create(); + SharedQuadState* sqs = + frame->render_pass_list[0]->CreateAndAppendSharedQuadState(); scoped_ptr quad = TextureDrawQuad::Create(); float vertex_opacity[4] = { 1.f, 1.f, 1.f, 1.f }; - quad->SetNew(sqs.get(), + quad->SetNew(sqs, gfx::Rect(0, 0, 10, 10), gfx::Rect(0, 0, 10, 10), gfx::Rect(0, 0, 10, 10), @@ -162,7 +162,6 @@ class LayerTreeHostDelegatedTest : public LayerTreeTest { SK_ColorTRANSPARENT, vertex_opacity, false); - frame->render_pass_list[0]->shared_quad_state_list.push_back(sqs.Pass()); frame->render_pass_list[0]->quad_list.push_back(quad.PassAs()); } @@ -182,10 +181,11 @@ class LayerTreeHostDelegatedTest : public LayerTreeTest { gfx::Transform()); frame->render_pass_list.push_back(pass.Pass()); - scoped_ptr sqs = SharedQuadState::Create(); + SharedQuadState* sqs = + frame->render_pass_list[0]->CreateAndAppendSharedQuadState(); scoped_ptr quad = RenderPassDrawQuad::Create(); - quad->SetNew(sqs.get(), + quad->SetNew(sqs, output_rect, output_rect, id, @@ -195,7 +195,6 @@ class LayerTreeHostDelegatedTest : public LayerTreeTest { gfx::Rect(0, 0, 1, 1), // mask_uv_rect filters, background_filters); - frame->render_pass_list[0]->shared_quad_state_list.push_back(sqs.Pass()); frame->render_pass_list[0]->quad_list.push_back(quad.PassAs()); } diff --git a/content/common/cc_messages.cc b/content/common/cc_messages.cc index 079cb2a98da9..87201c463233 100644 --- a/content/common/cc_messages.cc +++ b/content/common/cc_messages.cc @@ -504,10 +504,9 @@ bool ParamTraits::Read( // If the quad has a new shared quad state, read it in. if (last_shared_quad_state_index != shared_quad_state_index) { - scoped_ptr state(cc::SharedQuadState::Create()); - if (!ReadParam(m, iter, state.get())) + cc::SharedQuadState* state = p->CreateAndAppendSharedQuadState(); + if (!ReadParam(m, iter, state)) return false; - p->shared_quad_state_list.push_back(state.Pass()); last_shared_quad_state_index = shared_quad_state_index; } diff --git a/content/common/cc_messages_perftest.cc b/content/common/cc_messages_perftest.cc index 87aa2e89e15e..7589128c23b1 100644 --- a/content/common/cc_messages_perftest.cc +++ b/content/common/cc_messages_perftest.cc @@ -65,7 +65,7 @@ TEST_F(CCMessagesPerfTest, DelegatedFrame_ManyQuads_1_4000) { scoped_ptr frame(new CompositorFrame); scoped_ptr render_pass = RenderPass::Create(); - render_pass->shared_quad_state_list.push_back(SharedQuadState::Create()); + render_pass->CreateAndAppendSharedQuadState(); for (int i = 0; i < 4000; ++i) { render_pass->quad_list.push_back( PictureDrawQuad::Create().PassAs()); @@ -83,7 +83,7 @@ TEST_F(CCMessagesPerfTest, DelegatedFrame_ManyQuads_1_100000) { scoped_ptr frame(new CompositorFrame); scoped_ptr render_pass = RenderPass::Create(); - render_pass->shared_quad_state_list.push_back(SharedQuadState::Create()); + render_pass->CreateAndAppendSharedQuadState(); for (int i = 0; i < 100000; ++i) { render_pass->quad_list.push_back( PictureDrawQuad::Create().PassAs()); @@ -102,7 +102,7 @@ TEST_F(CCMessagesPerfTest, DelegatedFrame_ManyQuads_4000_4000) { scoped_ptr render_pass = RenderPass::Create(); for (int i = 0; i < 4000; ++i) { - render_pass->shared_quad_state_list.push_back(SharedQuadState::Create()); + render_pass->CreateAndAppendSharedQuadState(); render_pass->quad_list.push_back( PictureDrawQuad::Create().PassAs()); render_pass->quad_list.back()->shared_quad_state = @@ -120,7 +120,7 @@ TEST_F(CCMessagesPerfTest, DelegatedFrame_ManyQuads_100000_100000) { scoped_ptr render_pass = RenderPass::Create(); for (int i = 0; i < 100000; ++i) { - render_pass->shared_quad_state_list.push_back(SharedQuadState::Create()); + render_pass->CreateAndAppendSharedQuadState(); render_pass->quad_list.push_back( PictureDrawQuad::Create().PassAs()); render_pass->quad_list.back()->shared_quad_state = @@ -141,7 +141,7 @@ TEST_F(CCMessagesPerfTest, for (int i = 0; i < 1000; ++i) { scoped_ptr render_pass = RenderPass::Create(); for (int j = 0; j < 100; ++j) { - render_pass->shared_quad_state_list.push_back(SharedQuadState::Create()); + render_pass->CreateAndAppendSharedQuadState(); render_pass->quad_list.push_back( PictureDrawQuad::Create().PassAs()); render_pass->quad_list.back()->shared_quad_state = diff --git a/content/common/cc_messages_unittest.cc b/content/common/cc_messages_unittest.cc index 546fe3081f29..ee656292bf21 100644 --- a/content/common/cc_messages_unittest.cc +++ b/content/common/cc_messages_unittest.cc @@ -275,7 +275,14 @@ TEST_F(CCMessagesTest, AllQuads) { arbitrary_filters2.Append(FilterOperation::CreateBrightnessFilter( arbitrary_float2)); - scoped_ptr shared_state1_in = SharedQuadState::Create(); + scoped_ptr pass_in = RenderPass::Create(); + pass_in->SetAll(arbitrary_id, + arbitrary_rect1, + arbitrary_rect2, + arbitrary_matrix, + arbitrary_bool1); + + SharedQuadState* shared_state1_in = pass_in->CreateAndAppendSharedQuadState(); shared_state1_in->SetAll(arbitrary_matrix, arbitrary_size1, arbitrary_rect1, @@ -283,11 +290,21 @@ TEST_F(CCMessagesTest, AllQuads) { arbitrary_bool1, arbitrary_float1, arbitrary_blend_mode1); - scoped_ptr shared_state1_cmp = shared_state1_in->Copy(); + + scoped_ptr pass_cmp = RenderPass::Create(); + 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 checkerboard_in = CheckerboardDrawQuad::Create(); - checkerboard_in->SetAll(shared_state1_in.get(), + checkerboard_in->SetAll(shared_state1_in, arbitrary_rect1, arbitrary_rect2_inside_rect1, arbitrary_rect1_inside_rect1, @@ -298,7 +315,7 @@ TEST_F(CCMessagesTest, AllQuads) { scoped_ptr debugborder_in = DebugBorderDrawQuad::Create(); - debugborder_in->SetAll(shared_state1_in.get(), + debugborder_in->SetAll(shared_state1_in, arbitrary_rect3, arbitrary_rect1_inside_rect3, arbitrary_rect2_inside_rect3, @@ -310,7 +327,7 @@ TEST_F(CCMessagesTest, AllQuads) { scoped_ptr iosurface_in = IOSurfaceDrawQuad::Create(); - iosurface_in->SetAll(shared_state1_in.get(), + iosurface_in->SetAll(shared_state1_in, arbitrary_rect2, arbitrary_rect2_inside_rect2, arbitrary_rect1_inside_rect2, @@ -321,7 +338,7 @@ TEST_F(CCMessagesTest, AllQuads) { scoped_ptr iosurface_cmp = iosurface_in->Copy( iosurface_in->shared_quad_state); - scoped_ptr shared_state2_in = SharedQuadState::Create(); + SharedQuadState* shared_state2_in = pass_in->CreateAndAppendSharedQuadState(); shared_state2_in->SetAll(arbitrary_matrix, arbitrary_size2, arbitrary_rect2, @@ -329,11 +346,13 @@ TEST_F(CCMessagesTest, AllQuads) { arbitrary_bool1, arbitrary_float2, arbitrary_blend_mode2); - scoped_ptr shared_state2_cmp = shared_state2_in->Copy(); + SharedQuadState* shared_state2_cmp = + pass_cmp->CreateAndAppendSharedQuadState(); + shared_state2_cmp->CopyFrom(shared_state2_in); scoped_ptr renderpass_in = RenderPassDrawQuad::Create(); - renderpass_in->SetAll(shared_state2_in.get(), + renderpass_in->SetAll(shared_state2_in, arbitrary_rect1, arbitrary_rect2_inside_rect1, arbitrary_rect1_inside_rect1, @@ -348,7 +367,7 @@ TEST_F(CCMessagesTest, AllQuads) { scoped_ptr renderpass_cmp = renderpass_in->Copy( renderpass_in->shared_quad_state, renderpass_in->render_pass_id); - scoped_ptr shared_state3_in = SharedQuadState::Create(); + SharedQuadState* shared_state3_in = pass_in->CreateAndAppendSharedQuadState(); shared_state3_in->SetAll(arbitrary_matrix, arbitrary_size3, arbitrary_rect3, @@ -356,11 +375,13 @@ TEST_F(CCMessagesTest, AllQuads) { arbitrary_bool1, arbitrary_float3, arbitrary_blend_mode3); - scoped_ptr shared_state3_cmp = shared_state3_in->Copy(); + SharedQuadState* shared_state3_cmp = + pass_cmp->CreateAndAppendSharedQuadState(); + shared_state3_cmp->CopyFrom(shared_state3_in); scoped_ptr solidcolor_in = SolidColorDrawQuad::Create(); - solidcolor_in->SetAll(shared_state3_in.get(), + solidcolor_in->SetAll(shared_state3_in, arbitrary_rect3, arbitrary_rect1_inside_rect3, arbitrary_rect2_inside_rect3, @@ -372,7 +393,7 @@ TEST_F(CCMessagesTest, AllQuads) { scoped_ptr streamvideo_in = StreamVideoDrawQuad::Create(); - streamvideo_in->SetAll(shared_state3_in.get(), + streamvideo_in->SetAll(shared_state3_in, arbitrary_rect2, arbitrary_rect2_inside_rect2, arbitrary_rect1_inside_rect2, @@ -384,17 +405,17 @@ TEST_F(CCMessagesTest, AllQuads) { int arbitrary_surface_id = 3; scoped_ptr surface_in = SurfaceDrawQuad::Create(); - surface_in->SetAll(shared_state3_in.get(), - arbitrary_rect2, - arbitrary_rect2_inside_rect2, - arbitrary_rect1_inside_rect2, - arbitrary_bool1, - arbitrary_surface_id); + surface_in->SetAll(shared_state3_in, + arbitrary_rect2, + arbitrary_rect2_inside_rect2, + arbitrary_rect1_inside_rect2, + arbitrary_bool1, + arbitrary_surface_id); scoped_ptr surface_cmp = surface_in->Copy( surface_in->shared_quad_state); scoped_ptr texture_in = TextureDrawQuad::Create(); - texture_in->SetAll(shared_state3_in.get(), + texture_in->SetAll(shared_state3_in, arbitrary_rect2, arbitrary_rect2_inside_rect2, arbitrary_rect1_inside_rect2, @@ -410,7 +431,7 @@ TEST_F(CCMessagesTest, AllQuads) { texture_in->shared_quad_state); scoped_ptr tile_in = TileDrawQuad::Create(); - tile_in->SetAll(shared_state3_in.get(), + tile_in->SetAll(shared_state3_in, arbitrary_rect2, arbitrary_rect2_inside_rect2, arbitrary_rect1_inside_rect2, @@ -424,7 +445,7 @@ TEST_F(CCMessagesTest, AllQuads) { scoped_ptr yuvvideo_in = YUVVideoDrawQuad::Create(); - yuvvideo_in->SetAll(shared_state3_in.get(), + yuvvideo_in->SetAll(shared_state3_in, arbitrary_rect1, arbitrary_rect2_inside_rect1, arbitrary_rect1_inside_rect1, @@ -438,20 +459,10 @@ TEST_F(CCMessagesTest, AllQuads) { scoped_ptr yuvvideo_cmp = yuvvideo_in->Copy( yuvvideo_in->shared_quad_state); - scoped_ptr pass_in = RenderPass::Create(); - pass_in->SetAll(arbitrary_id, - arbitrary_rect1, - arbitrary_rect2, - arbitrary_matrix, - arbitrary_bool1); - - pass_in->shared_quad_state_list.push_back(shared_state1_in.Pass()); pass_in->quad_list.push_back(checkerboard_in.PassAs()); pass_in->quad_list.push_back(debugborder_in.PassAs()); pass_in->quad_list.push_back(iosurface_in.PassAs()); pass_in->quad_list.push_back(renderpass_in.PassAs()); - pass_in->shared_quad_state_list.push_back(shared_state2_in.Pass()); - pass_in->shared_quad_state_list.push_back(shared_state3_in.Pass()); pass_in->quad_list.push_back(solidcolor_in.PassAs()); pass_in->quad_list.push_back(streamvideo_in.PassAs()); pass_in->quad_list.push_back(surface_in.PassAs()); @@ -459,20 +470,11 @@ TEST_F(CCMessagesTest, AllQuads) { pass_in->quad_list.push_back(tile_in.PassAs()); pass_in->quad_list.push_back(yuvvideo_in.PassAs()); - scoped_ptr pass_cmp = RenderPass::Create(); - pass_cmp->SetAll(arbitrary_id, - arbitrary_rect1, - arbitrary_rect2, - arbitrary_matrix, - arbitrary_bool1); - pass_cmp->shared_quad_state_list.push_back(shared_state1_cmp.Pass()); pass_cmp->quad_list.push_back(checkerboard_cmp.PassAs()); pass_cmp->quad_list.push_back(debugborder_cmp.PassAs()); pass_cmp->quad_list.push_back(iosurface_cmp.PassAs()); pass_cmp->quad_list.push_back(renderpass_cmp.PassAs()); - pass_cmp->shared_quad_state_list.push_back(shared_state2_cmp.Pass()); - pass_cmp->shared_quad_state_list.push_back(shared_state3_cmp.Pass()); pass_cmp->quad_list.push_back(solidcolor_cmp.PassAs()); pass_cmp->quad_list.push_back(streamvideo_cmp.PassAs()); pass_cmp->quad_list.push_back(surface_cmp.PassAs()); @@ -544,7 +546,7 @@ TEST_F(CCMessagesTest, UnusedSharedQuadStates) { false); // The first SharedQuadState is used. - scoped_ptr shared_state1_in = SharedQuadState::Create(); + SharedQuadState* shared_state1_in = pass_in->CreateAndAppendSharedQuadState(); shared_state1_in->SetAll(gfx::Transform(), gfx::Size(1, 1), gfx::Rect(), @@ -554,7 +556,7 @@ TEST_F(CCMessagesTest, UnusedSharedQuadStates) { SkXfermode::kSrcOver_Mode); quad = CheckerboardDrawQuad::Create(); - quad->SetAll(shared_state1_in.get(), + quad->SetAll(shared_state1_in, gfx::Rect(10, 10), gfx::Rect(10, 10), gfx::Rect(10, 10), @@ -563,7 +565,7 @@ TEST_F(CCMessagesTest, UnusedSharedQuadStates) { pass_in->quad_list.push_back(quad.PassAs()); // The second and third SharedQuadStates are not used. - scoped_ptr shared_state2_in = SharedQuadState::Create(); + SharedQuadState* shared_state2_in = pass_in->CreateAndAppendSharedQuadState(); shared_state2_in->SetAll(gfx::Transform(), gfx::Size(2, 2), gfx::Rect(), @@ -572,7 +574,7 @@ TEST_F(CCMessagesTest, UnusedSharedQuadStates) { 1.f, SkXfermode::kSrcOver_Mode); - scoped_ptr shared_state3_in = SharedQuadState::Create(); + SharedQuadState* shared_state3_in = pass_in->CreateAndAppendSharedQuadState(); shared_state3_in->SetAll(gfx::Transform(), gfx::Size(3, 3), gfx::Rect(), @@ -582,7 +584,7 @@ TEST_F(CCMessagesTest, UnusedSharedQuadStates) { SkXfermode::kSrcOver_Mode); // The fourth SharedQuadState is used. - scoped_ptr shared_state4_in = SharedQuadState::Create(); + SharedQuadState* shared_state4_in = pass_in->CreateAndAppendSharedQuadState(); shared_state4_in->SetAll(gfx::Transform(), gfx::Size(4, 4), gfx::Rect(), @@ -592,7 +594,7 @@ TEST_F(CCMessagesTest, UnusedSharedQuadStates) { SkXfermode::kSrcOver_Mode); quad = CheckerboardDrawQuad::Create(); - quad->SetAll(shared_state4_in.get(), + quad->SetAll(shared_state4_in, gfx::Rect(10, 10), gfx::Rect(10, 10), gfx::Rect(10, 10), @@ -601,7 +603,7 @@ TEST_F(CCMessagesTest, UnusedSharedQuadStates) { pass_in->quad_list.push_back(quad.PassAs()); // The fifth is not used again. - scoped_ptr shared_state5_in = SharedQuadState::Create(); + SharedQuadState* shared_state5_in = pass_in->CreateAndAppendSharedQuadState(); shared_state5_in->SetAll(gfx::Transform(), gfx::Size(5, 5), gfx::Rect(), @@ -610,12 +612,6 @@ TEST_F(CCMessagesTest, UnusedSharedQuadStates) { 1.f, SkXfermode::kSrcOver_Mode); - pass_in->shared_quad_state_list.push_back(shared_state1_in.Pass()); - pass_in->shared_quad_state_list.push_back(shared_state2_in.Pass()); - pass_in->shared_quad_state_list.push_back(shared_state3_in.Pass()); - pass_in->shared_quad_state_list.push_back(shared_state4_in.Pass()); - pass_in->shared_quad_state_list.push_back(shared_state5_in.Pass()); - // 5 SharedQuadStates go in. ASSERT_EQ(5u, pass_in->shared_quad_state_list.size()); ASSERT_EQ(2u, pass_in->quad_list.size()); -- 2.11.4.GIT