summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--cc/layers/delegated_frame_provider_unittest.cc6
-rw-r--r--cc/output/overlay_unittest.cc3
-rw-r--r--cc/output/renderer_pixeltest.cc522
-rw-r--r--cc/output/software_renderer_unittest.cc43
-rw-r--r--cc/quads/render_pass_unittest.cc25
-rw-r--r--cc/surfaces/surface_aggregator_test_helpers.cc3
-rw-r--r--cc/surfaces/surface_aggregator_unittest.cc3
-rw-r--r--cc/surfaces/surfaces_pixeltest.cc35
-rw-r--r--cc/test/render_pass_test_common.cc41
-rw-r--r--cc/test/render_pass_test_common.h1
-rw-r--r--cc/trees/layer_tree_host_unittest_delegated.cc19
-rw-r--r--content/common/cc_messages.cc5
-rw-r--r--content/common/cc_messages_perftest.cc10
-rw-r--r--content/common/cc_messages_unittest.cc102
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 a8e1683..0655cf3 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<SharedQuadState> sqs = SharedQuadState::Create();
+ SharedQuadState* sqs =
+ frame->render_pass_list[0]->CreateAndAppendSharedQuadState();
scoped_ptr<TextureDrawQuad> 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<DrawQuad>());
}
diff --git a/cc/output/overlay_unittest.cc b/cc/output/overlay_unittest.cc
index c258c9d..69c11c0 100644
--- a/cc/output/overlay_unittest.cc
+++ b/cc/output/overlay_unittest.cc
@@ -111,9 +111,8 @@ scoped_ptr<RenderPass> CreateRenderPass() {
gfx::Transform(),
has_transparent_background);
- scoped_ptr<SharedQuadState> 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 869bb9b..291563b 100644
--- a/cc/output/renderer_pixeltest.cc
+++ b/cc/output/renderer_pixeltest.cc
@@ -48,15 +48,17 @@ scoped_ptr<RenderPass> CreateTestRenderPass(
return pass.Pass();
}
-scoped_ptr<SharedQuadState> 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<SharedQuadState> 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<SharedQuadState> CreateTestSharedQuadState(
is_clipped,
opacity,
blend_mode);
- return shared_state.Pass();
+ return shared_state;
}
-scoped_ptr<SharedQuadState> 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<SharedQuadState> CreateTestSharedQuadStateClipped(
const bool is_clipped = true;
const float opacity = 1.0f;
const SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode;
- scoped_ptr<SharedQuadState> 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<SharedQuadState> CreateTestSharedQuadStateClipped(
is_clipped,
opacity,
blend_mode);
- return shared_state.Pass();
+ return shared_state;
}
scoped_ptr<DrawQuad> CreateTestRenderPassDrawQuad(
@@ -205,11 +208,11 @@ TYPED_TEST(RendererPixelTest, SimpleGreenRect) {
RenderPass::Id id(1, 1);
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
- scoped_ptr<SharedQuadState> shared_state =
- CreateTestSharedQuadState(gfx::Transform(), rect);
+ SharedQuadState* shared_state =
+ CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
scoped_ptr<SolidColorDrawQuad> 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<DrawQuad>());
@@ -230,25 +233,22 @@ TYPED_TEST(RendererPixelTest, SimpleGreenRect_NonRootRenderPass) {
scoped_ptr<RenderPass> child_pass =
CreateTestRenderPass(child_id, small_rect, gfx::Transform());
- scoped_ptr<SharedQuadState> child_shared_state =
- CreateTestSharedQuadState(gfx::Transform(), small_rect);
+ SharedQuadState* child_shared_state =
+ CreateTestSharedQuadState(child_pass.get(), gfx::Transform(), small_rect);
scoped_ptr<SolidColorDrawQuad> 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<DrawQuad>());
RenderPass::Id root_id(1, 1);
scoped_ptr<RenderPass> root_pass =
CreateTestRenderPass(root_id, rect, gfx::Transform());
- scoped_ptr<SharedQuadState> root_shared_state =
- CreateTestSharedQuadState(gfx::Transform(), rect);
+ SharedQuadState* root_shared_state =
+ CreateTestSharedQuadState(root_pass.get(), gfx::Transform(), rect);
scoped_ptr<DrawQuad> 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<DrawQuad>());
RenderPass* child_pass_ptr = child_pass.get();
@@ -270,20 +270,20 @@ TYPED_TEST(RendererPixelTest, PremultipliedTextureWithoutBackground) {
RenderPass::Id id(1, 1);
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
- scoped_ptr<SharedQuadState> shared_state =
- CreateTestSharedQuadState(gfx::Transform(), rect);
+ SharedQuadState* shared_state =
+ CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
- 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.get(),
- this->resource_provider_.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>());
scoped_ptr<SolidColorDrawQuad> 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<DrawQuad>());
RenderPassList pass_list;
@@ -301,23 +301,23 @@ TYPED_TEST(RendererPixelTest, PremultipliedTextureWithBackground) {
RenderPass::Id id(1, 1);
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
- scoped_ptr<SharedQuadState> 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<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.get(),
+ SK_ColorGREEN, // Background color.
+ true, // Premultiplied alpha.
+ texture_quad_state,
this->resource_provider_.get());
pass->quad_list.push_back(texture_quad.PassAs<DrawQuad>());
- scoped_ptr<SharedQuadState> color_quad_state =
- CreateTestSharedQuadState(gfx::Transform(), rect);
+ SharedQuadState* color_quad_state =
+ CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
scoped_ptr<SolidColorDrawQuad> 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<DrawQuad>());
RenderPassList pass_list;
@@ -336,20 +336,20 @@ TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithoutBackground) {
RenderPass::Id id(1, 1);
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
- scoped_ptr<SharedQuadState> shared_state =
- CreateTestSharedQuadState(gfx::Transform(), rect);
+ SharedQuadState* shared_state =
+ CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
- 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.get(),
- this->resource_provider_.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>());
scoped_ptr<SolidColorDrawQuad> 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<DrawQuad>());
RenderPassList pass_list;
@@ -368,23 +368,23 @@ TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithBackground) {
RenderPass::Id id(1, 1);
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
- scoped_ptr<SharedQuadState> 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<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.get(),
+ SK_ColorGREEN, // Background color.
+ false, // Premultiplied alpha.
+ texture_quad_state,
this->resource_provider_.get());
pass->quad_list.push_back(texture_quad.PassAs<DrawQuad>());
- scoped_ptr<SharedQuadState> color_quad_state =
- CreateTestSharedQuadState(gfx::Transform(), rect);
+ SharedQuadState* color_quad_state =
+ CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
scoped_ptr<SolidColorDrawQuad> 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<DrawQuad>());
RenderPassList pass_list;
@@ -552,11 +552,11 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVRect) {
RenderPass::Id id(1, 1);
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
- scoped_ptr<SharedQuadState> shared_state =
- CreateTestSharedQuadState(gfx::Transform(), rect);
+ SharedQuadState* shared_state =
+ CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
scoped_ptr<YUVVideoDrawQuad> 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<RenderPass> pass = CreateTestRootRenderPass(id, rect);
- scoped_ptr<SharedQuadState> 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<YUVVideoDrawQuad> 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<RenderPass> pass = CreateTestRootRenderPass(id, rect);
- scoped_ptr<SharedQuadState> 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<YUVVideoDrawQuad> 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<RenderPass> pass = CreateTestRootRenderPass(id, rect);
- scoped_ptr<SharedQuadState> 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<YUVVideoDrawQuad> 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<RenderPass> pass = CreateTestRootRenderPass(id, rect);
- scoped_ptr<SharedQuadState> 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<YUVVideoDrawQuad> 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<RenderPass> pass = CreateTestRootRenderPass(id, rect);
- scoped_ptr<SharedQuadState> shared_state =
- CreateTestSharedQuadState(gfx::Transform(), rect);
+ SharedQuadState* shared_state =
+ CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
scoped_ptr<YUVVideoDrawQuad> 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<DrawQuad>());
scoped_ptr<SolidColorDrawQuad> 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<DrawQuad>());
@@ -726,11 +726,11 @@ TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) {
RenderPass::Id id(1, 1);
scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
- scoped_ptr<SharedQuadState> shared_state =
- CreateTestSharedQuadState(gfx::Transform(), rect);
+ SharedQuadState* shared_state =
+ CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
scoped_ptr<YUVVideoDrawQuad> 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<DrawQuad>());
scoped_ptr<SolidColorDrawQuad> 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<DrawQuad>());
@@ -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<SharedQuadState> 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<SolidColorDrawQuad> 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<SolidColorDrawQuad> 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<SharedQuadState> blank_state =
- CreateTestSharedQuadState(content_to_target_transform, viewport_rect);
+ SharedQuadState* blank_state = CreateTestSharedQuadState(
+ child_pass.get(), content_to_target_transform, viewport_rect);
scoped_ptr<SolidColorDrawQuad> 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<DrawQuad>());
child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
child_pass->quad_list.push_back(white.PassAs<DrawQuad>());
- scoped_ptr<SharedQuadState> 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<RenderPassDrawQuad> 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<SharedQuadState> 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<SolidColorDrawQuad> 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<SolidColorDrawQuad> 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<SharedQuadState> blank_state =
- CreateTestSharedQuadState(content_to_target_transform, viewport_rect);
+ SharedQuadState* blank_state = CreateTestSharedQuadState(
+ child_pass.get(), content_to_target_transform, viewport_rect);
scoped_ptr<SolidColorDrawQuad> 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<DrawQuad>());
child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
child_pass->quad_list.push_back(white.PassAs<DrawQuad>());
- scoped_ptr<SharedQuadState> 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<RenderPassDrawQuad> 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<SharedQuadState> 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<SolidColorDrawQuad> 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<SolidColorDrawQuad> 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<SharedQuadState> blank_state =
- CreateTestSharedQuadState(content_to_target_transform, viewport_rect);
+ SharedQuadState* blank_state = CreateTestSharedQuadState(
+ child_pass.get(), content_to_target_transform, viewport_rect);
scoped_ptr<SolidColorDrawQuad> 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<DrawQuad>());
child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
child_pass->quad_list.push_back(white.PassAs<DrawQuad>());
- scoped_ptr<SharedQuadState> 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<RenderPassDrawQuad> 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<SharedQuadState> 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<SolidColorDrawQuad> 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<SolidColorDrawQuad> 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<SharedQuadState> blank_state =
- CreateTestSharedQuadState(content_to_target_transform, viewport_rect);
+ SharedQuadState* blank_state = CreateTestSharedQuadState(
+ child_pass.get(), content_to_target_transform, viewport_rect);
scoped_ptr<SolidColorDrawQuad> 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<DrawQuad>());
child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
child_pass->quad_list.push_back(white.PassAs<DrawQuad>());
- scoped_ptr<SharedQuadState> 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<RenderPassDrawQuad> 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<SharedQuadState> 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<SolidColorDrawQuad> 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<SolidColorDrawQuad> 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<DrawQuad>());
child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
- scoped_ptr<SharedQuadState> 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<SharedQuadState> 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<SolidColorDrawQuad> 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<SolidColorDrawQuad> 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<DrawQuad>());
child_pass->quad_list.push_back(yellow.PassAs<DrawQuad>());
@@ -1185,17 +1177,15 @@ TYPED_TEST(RendererPixelTest, EnlargedRenderPassTextureWithAntiAliasing) {
gfx::Transform aa_transform;
aa_transform.Translate(0.5, 0.0);
- scoped_ptr<SharedQuadState> 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<SharedQuadState> root_shared_state =
- CreateTestSharedQuadState(gfx::Transform(), viewport_rect);
+ SharedQuadState* root_shared_state = CreateTestSharedQuadState(
+ root_pass.get(), gfx::Transform(), viewport_rect);
scoped_ptr<SolidColorDrawQuad> 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<RenderPass> root_pass =
CreateTestRootRenderPass(root_pass_id, viewport_rect);
- scoped_ptr<SharedQuadState> 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<RenderPass> child_pass =
CreateTestRenderPass(child_pass_id, viewport_rect, transform_to_root);
- scoped_ptr<SharedQuadState> 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<SolidColorDrawQuad> 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<DrawQuad>());
// Make a mask.
@@ -1289,7 +1276,7 @@ TYPED_TEST(RendererPixelTest, RenderPassAndMaskWithPartialQuad) {
// Set up a mask on the RenderPassDrawQuad.
scoped_ptr<RenderPassDrawQuad> 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<SolidColorDrawQuad> 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<SharedQuadState> 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<SolidColorDrawQuad> 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<DrawQuad>());
- filter_pass->shared_quad_state_list.push_back(shared_state.Pass());
}
{
- scoped_ptr<SharedQuadState> 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<RenderPassDrawQuad> 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<DrawQuad>());
- 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<SharedQuadState> 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<SolidColorDrawQuad> 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<DrawQuad>());
- 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<SharedQuadState> 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<SolidColorDrawQuad> 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<DrawQuad>());
- 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<SharedQuadState> 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<SolidColorDrawQuad> 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<DrawQuad>());
- root_pass->shared_quad_state_list.push_back(shared_state.Pass());
right_rect += gfx::Vector2d(0, right_rect.height() + 1);
}
- scoped_ptr<SharedQuadState> 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<SolidColorDrawQuad> 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<DrawQuad>());
- 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<RenderPass> pass = CreateTestRootRenderPass(id, rect);
- scoped_ptr<SharedQuadState> blue_shared_state =
- CreateTestSharedQuadState(gfx::Transform(), rect);
+ SharedQuadState* blue_shared_state =
+ CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
scoped_ptr<SolidColorDrawQuad> 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<DrawQuad>());
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<RenderPass> pass = CreateTestRootRenderPass(id, rect);
- scoped_ptr<SharedQuadState> green_shared_state =
- CreateTestSharedQuadState(gfx::Transform(), rect);
+ SharedQuadState* green_shared_state =
+ CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
scoped_ptr<SolidColorDrawQuad> 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<DrawQuad>());
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<SharedQuadState> 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<SolidColorDrawQuad> 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<DrawQuad>());
- scoped_ptr<SharedQuadState> 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<RenderPass> pass = CreateTestRootRenderPass(id, rect);
- scoped_ptr<SharedQuadState> blue_shared_state =
- CreateTestSharedQuadState(gfx::Transform(), rect);
+ SharedQuadState* blue_shared_state =
+ CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
scoped_ptr<SolidColorDrawQuad> 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<DrawQuad>());
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<SharedQuadState> 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<SolidColorDrawQuad> 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<DrawQuad>());
gfx::Transform yellow_content_to_target_transform;
yellow_content_to_target_transform.Rotate(5);
- scoped_ptr<SharedQuadState> 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<SolidColorDrawQuad> 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<DrawQuad>());
gfx::Transform blue_content_to_target_transform;
- scoped_ptr<SharedQuadState> 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<SolidColorDrawQuad> 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<DrawQuad>());
@@ -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<SharedQuadState> 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<SolidColorDrawQuad> 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<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);
- scoped_ptr<SharedQuadState> 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<SolidColorDrawQuad> 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<DrawQuad>());
gfx::Transform blue_content_to_target_transform;
- scoped_ptr<SharedQuadState> 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<SolidColorDrawQuad> 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<DrawQuad>());
@@ -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<SharedQuadState> 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<SolidColorDrawQuad> 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<DrawQuad>());
gfx::Transform green_content_to_target_transform;
- scoped_ptr<SharedQuadState> 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<SolidColorDrawQuad> 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<DrawQuad>());
@@ -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<SharedQuadState> 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<SolidColorDrawQuad> 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<DrawQuad>());
gfx::Rect green_rect(19, 7, 180, 10);
- scoped_ptr<SharedQuadState> green_shared_state =
- CreateTestSharedQuadState(gfx::Transform(), green_rect);
+ SharedQuadState* green_shared_state =
+ CreateTestSharedQuadState(pass.get(), gfx::Transform(), green_rect);
scoped_ptr<SolidColorDrawQuad> 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<DrawQuad>());
- scoped_ptr<SharedQuadState> blue_shared_state =
- CreateTestSharedQuadState(gfx::Transform(), rect);
+ SharedQuadState* blue_shared_state =
+ CreateTestSharedQuadState(pass.get(), gfx::Transform(), rect);
scoped_ptr<SolidColorDrawQuad> 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<DrawQuad>());
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<SharedQuadState> 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<PictureDrawQuad> 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<SharedQuadState> 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<PictureDrawQuad> 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<SharedQuadState> 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<PictureDrawQuad> 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<SharedQuadState> 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<PictureDrawQuad> 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<SharedQuadState> shared_state =
- CreateTestSharedQuadState(content_to_target_transform, viewport);
+ SharedQuadState* shared_state = CreateTestSharedQuadState(
+ pass.get(), content_to_target_transform, viewport);
scoped_ptr<PictureDrawQuad> 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<SharedQuadState> 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<PictureDrawQuad> 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<DrawQuad>());
scoped_ptr<PictureDrawQuad> 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<SharedQuadState> 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<SolidColorDrawQuad> 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<SharedQuadState> 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<PictureDrawQuad> 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<SharedQuadState> 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<SolidColorDrawQuad> 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<RenderPass> pass = CreateTestRootRenderPass(id, rect);
- scoped_ptr<SharedQuadState> 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<TextureDrawQuad> 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 2fd6c6d5..af4343b 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<SharedQuadState> shared_quad_state = SharedQuadState::Create();
+ RenderPass::Id root_render_pass_id = RenderPass::Id(1, 1);
+ scoped_ptr<TestRenderPass> 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<TestRenderPass> root_render_pass = TestRenderPass::Create();
- root_render_pass->SetNew(
- root_render_pass_id, outer_rect, outer_rect, gfx::Transform());
scoped_ptr<SolidColorDrawQuad> 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<SolidColorDrawQuad> 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<DrawQuad>());
root_render_pass->AppendQuad(outer_quad.PassAs<DrawQuad>());
@@ -160,7 +161,12 @@ TEST_F(SoftwareRendererTest, TileQuad) {
gfx::Rect root_rect = outer_rect;
- scoped_ptr<SharedQuadState> shared_quad_state = SharedQuadState::Create();
+ RenderPass::Id root_render_pass_id = RenderPass::Id(1, 1);
+ scoped_ptr<TestRenderPass> 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<TestRenderPass> root_render_pass = TestRenderPass::Create();
- root_render_pass->SetNew(
- root_render_pass_id, root_rect, root_rect, gfx::Transform());
scoped_ptr<TileDrawQuad> 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<TileDrawQuad> 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<SharedQuadState> shared_quad_state = SharedQuadState::Create();
+ RenderPass::Id root_render_pass_id = RenderPass::Id(1, 1);
+ scoped_ptr<TestRenderPass> 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<TestRenderPass> root_render_pass = TestRenderPass::Create();
- root_render_pass->SetNew(
- root_render_pass_id, root_rect, root_rect, gfx::Transform());
scoped_ptr<TileDrawQuad> 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 f714dbe..7f723a4 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<SharedQuadState> 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<CheckerboardDrawQuad> checkerboard_quad =
CheckerboardDrawQuad::Create();
@@ -130,7 +129,7 @@ TEST(RenderPassTest, CopyAllShouldBeIdentical) {
has_transparent_background);
// Two quads using one shared state.
- scoped_ptr<SharedQuadState> 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<CheckerboardDrawQuad> checkerboard_quad1 =
CheckerboardDrawQuad::Create();
@@ -157,7 +155,7 @@ TEST(RenderPassTest, CopyAllShouldBeIdentical) {
pass->quad_list.push_back(checkerboard_quad2.PassAs<DrawQuad>());
// And two quads using another shared state.
- scoped_ptr<SharedQuadState> 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<CheckerboardDrawQuad> checkerboard_quad3 =
CheckerboardDrawQuad::Create();
@@ -198,7 +195,8 @@ TEST(RenderPassTest, CopyAllShouldBeIdentical) {
contrib_transform_to_root,
contrib_has_transparent_background);
- scoped_ptr<SharedQuadState> 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<CheckerboardDrawQuad> contrib_quad =
CheckerboardDrawQuad::Create();
@@ -258,7 +255,7 @@ TEST(RenderPassTest, CopyAllWithCulledQuads) {
has_transparent_background);
// A shared state with a quad.
- scoped_ptr<SharedQuadState> 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<CheckerboardDrawQuad> checkerboard_quad1 =
CheckerboardDrawQuad::Create();
@@ -277,7 +273,7 @@ TEST(RenderPassTest, CopyAllWithCulledQuads) {
pass->quad_list.push_back(checkerboard_quad1.PassAs<DrawQuad>());
// A shared state with no quads, they were culled.
- scoped_ptr<SharedQuadState> 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<SharedQuadState> 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<SharedQuadState> 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<CheckerboardDrawQuad> checkerboard_quad2 =
CheckerboardDrawQuad::Create();
diff --git a/cc/surfaces/surface_aggregator_test_helpers.cc b/cc/surfaces/surface_aggregator_test_helpers.cc
index be6340e..6706c50 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<SharedQuadState> 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<SurfaceDrawQuad> 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 3f2fbd8..1809409 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<SharedQuadState> 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<SolidColorDrawQuad> 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 abcc532e..3559d53 100644
--- a/cc/surfaces/surfaces_pixeltest.cc
+++ b/cc/surfaces/surfaces_pixeltest.cc
@@ -23,7 +23,8 @@ class SurfacesPixelTest : public RendererPixelTest<GLRenderer> {
SurfaceManager manager_;
};
-scoped_ptr<SharedQuadState> 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<SharedQuadState> CreateTestSharedQuadState(
bool is_clipped = false;
float opacity = 1.f;
const SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode;
- scoped_ptr<SharedQuadState> 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<SharedQuadState> 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<RenderPass> 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<SolidColorDrawQuad> color_quad = SolidColorDrawQuad::Create();
bool force_anti_aliasing_off = false;
@@ -96,8 +97,8 @@ TEST_F(SurfacesPixelTest, DrawSimpleAggregatedFrame) {
scoped_ptr<RenderPass> 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<SurfaceDrawQuad> surface_quad = SurfaceDrawQuad::Create();
surface_quad->SetNew(pass->shared_quad_state_list.back(),
@@ -130,8 +131,8 @@ TEST_F(SurfacesPixelTest, DrawSimpleAggregatedFrame) {
scoped_ptr<RenderPass> 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<SolidColorDrawQuad> 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<SurfaceDrawQuad> 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<DrawQuad>());
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<SurfaceDrawQuad> 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<RenderPass> 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<SolidColorDrawQuad> top_color_quad =
SolidColorDrawQuad::Create();
@@ -259,8 +260,8 @@ TEST_F(SurfacesPixelTest, DrawAggregatedFrameWithSurfaceTransforms) {
scoped_ptr<RenderPass> 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<SolidColorDrawQuad> top_color_quad =
SolidColorDrawQuad::Create();
diff --git a/cc/test/render_pass_test_common.cc b/cc/test/render_pass_test_common.cc
index a68e00b..dd58b43 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<DrawQuad> quad) {
quad_list.push_back(quad.Pass());
}
-void TestRenderPass::AppendSharedQuadState(scoped_ptr<SharedQuadState> 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<SharedQuadState> 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<CheckerboardDrawQuad> 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<DrawQuad>());
scoped_ptr<DebugBorderDrawQuad> 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<DrawQuad>());
scoped_ptr<IOSurfaceDrawQuad> 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<RenderPassDrawQuad> 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<RenderPassDrawQuad> 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<SolidColorDrawQuad> 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<DrawQuad>());
scoped_ptr<StreamVideoDrawQuad> 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<DrawQuad>());
scoped_ptr<TextureDrawQuad> 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<DrawQuad>());
scoped_ptr<TileDrawQuad> 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<DrawQuad>());
- scoped_ptr<SharedQuadState> 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<TileDrawQuad> 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<DrawQuad>());
- scoped_ptr<SharedQuadState> 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<TileDrawQuad> 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<YUVVideoDrawQuad> 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<DrawQuad>());
-
- 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 651278f..24467ed 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<DrawQuad> quad);
- void AppendSharedQuadState(scoped_ptr<SharedQuadState> 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 a6562ae..02f8db3 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<SharedQuadState> 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<TextureDrawQuad> 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<DrawQuad>());
- 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<SharedQuadState> sqs = SharedQuadState::Create();
+ SharedQuadState* sqs =
+ frame->render_pass_list[0]->CreateAndAppendSharedQuadState();
scoped_ptr<TextureDrawQuad> 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<DrawQuad>());
}
@@ -182,10 +181,11 @@ class LayerTreeHostDelegatedTest : public LayerTreeTest {
gfx::Transform());
frame->render_pass_list.push_back(pass.Pass());
- scoped_ptr<SharedQuadState> sqs = SharedQuadState::Create();
+ SharedQuadState* sqs =
+ frame->render_pass_list[0]->CreateAndAppendSharedQuadState();
scoped_ptr<RenderPassDrawQuad> 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<DrawQuad>());
}
diff --git a/content/common/cc_messages.cc b/content/common/cc_messages.cc
index 079cb2a..87201c4 100644
--- a/content/common/cc_messages.cc
+++ b/content/common/cc_messages.cc
@@ -504,10 +504,9 @@ bool ParamTraits<cc::RenderPass>::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<cc::SharedQuadState> 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 87aa2e8..7589128 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<CompositorFrame> frame(new CompositorFrame);
scoped_ptr<RenderPass> 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<DrawQuad>());
@@ -83,7 +83,7 @@ TEST_F(CCMessagesPerfTest, DelegatedFrame_ManyQuads_1_100000) {
scoped_ptr<CompositorFrame> frame(new CompositorFrame);
scoped_ptr<RenderPass> 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<DrawQuad>());
@@ -102,7 +102,7 @@ TEST_F(CCMessagesPerfTest, DelegatedFrame_ManyQuads_4000_4000) {
scoped_ptr<RenderPass> 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<DrawQuad>());
render_pass->quad_list.back()->shared_quad_state =
@@ -120,7 +120,7 @@ TEST_F(CCMessagesPerfTest, DelegatedFrame_ManyQuads_100000_100000) {
scoped_ptr<RenderPass> 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<DrawQuad>());
render_pass->quad_list.back()->shared_quad_state =
@@ -141,7 +141,7 @@ TEST_F(CCMessagesPerfTest,
for (int i = 0; i < 1000; ++i) {
scoped_ptr<RenderPass> 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<DrawQuad>());
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 546fe30..ee65629 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<SharedQuadState> shared_state1_in = SharedQuadState::Create();
+ scoped_ptr<RenderPass> 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<SharedQuadState> shared_state1_cmp = shared_state1_in->Copy();
+
+ scoped_ptr<RenderPass> 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<CheckerboardDrawQuad> 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<DebugBorderDrawQuad> 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<IOSurfaceDrawQuad> 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<DrawQuad> iosurface_cmp = iosurface_in->Copy(
iosurface_in->shared_quad_state);
- scoped_ptr<SharedQuadState> 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<SharedQuadState> shared_state2_cmp = shared_state2_in->Copy();
+ SharedQuadState* shared_state2_cmp =
+ pass_cmp->CreateAndAppendSharedQuadState();
+ shared_state2_cmp->CopyFrom(shared_state2_in);
scoped_ptr<RenderPassDrawQuad> 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<RenderPassDrawQuad> renderpass_cmp = renderpass_in->Copy(
renderpass_in->shared_quad_state, renderpass_in->render_pass_id);
- scoped_ptr<SharedQuadState> 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<SharedQuadState> shared_state3_cmp = shared_state3_in->Copy();
+ SharedQuadState* shared_state3_cmp =
+ pass_cmp->CreateAndAppendSharedQuadState();
+ shared_state3_cmp->CopyFrom(shared_state3_in);
scoped_ptr<SolidColorDrawQuad> 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<StreamVideoDrawQuad> 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<SurfaceDrawQuad> 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<DrawQuad> surface_cmp = surface_in->Copy(
surface_in->shared_quad_state);
scoped_ptr<TextureDrawQuad> 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<TileDrawQuad> 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<YUVVideoDrawQuad> 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<DrawQuad> yuvvideo_cmp = yuvvideo_in->Copy(
yuvvideo_in->shared_quad_state);
- scoped_ptr<RenderPass> 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<DrawQuad>());
pass_in->quad_list.push_back(debugborder_in.PassAs<DrawQuad>());
pass_in->quad_list.push_back(iosurface_in.PassAs<DrawQuad>());
pass_in->quad_list.push_back(renderpass_in.PassAs<DrawQuad>());
- 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<DrawQuad>());
pass_in->quad_list.push_back(streamvideo_in.PassAs<DrawQuad>());
pass_in->quad_list.push_back(surface_in.PassAs<DrawQuad>());
@@ -459,20 +470,11 @@ TEST_F(CCMessagesTest, AllQuads) {
pass_in->quad_list.push_back(tile_in.PassAs<DrawQuad>());
pass_in->quad_list.push_back(yuvvideo_in.PassAs<DrawQuad>());
- scoped_ptr<RenderPass> 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<DrawQuad>());
pass_cmp->quad_list.push_back(debugborder_cmp.PassAs<DrawQuad>());
pass_cmp->quad_list.push_back(iosurface_cmp.PassAs<DrawQuad>());
pass_cmp->quad_list.push_back(renderpass_cmp.PassAs<DrawQuad>());
- 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<DrawQuad>());
pass_cmp->quad_list.push_back(streamvideo_cmp.PassAs<DrawQuad>());
pass_cmp->quad_list.push_back(surface_cmp.PassAs<DrawQuad>());
@@ -544,7 +546,7 @@ TEST_F(CCMessagesTest, UnusedSharedQuadStates) {
false);
// The first SharedQuadState is used.
- scoped_ptr<SharedQuadState> 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<DrawQuad>());
// The second and third SharedQuadStates are not used.
- scoped_ptr<SharedQuadState> 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<SharedQuadState> 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<SharedQuadState> 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<DrawQuad>());
// The fifth is not used again.
- scoped_ptr<SharedQuadState> 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());
generated by cgit v1.1 at 2024-09-22 13:51:44 +0000