Skip to content

GitLab

T
tangled
Commit d70cc671 authored by weiliangc@chromium.org's avatar weiliangc@chromium.org
Browse files
Options

Move Copy method from DrawQuad to RenderPass 

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

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

Follow 368403003.

BUG=344962

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

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@282640 0039d316-1c4b-4281-b951-d872f2087c98
parent f0bbcdc2
Show whitespace changes
Inline Side-by-side
Showing with 360 additions and 361 deletions
cc/layers/delegated_renderer_layer_impl.cc
View file @ d70cc671
......@@ -442,9 +442,9 @@ void DelegatedRendererLayerImpl::AppendRenderPassQuads(
if (quad_visible_rect.IsEmpty())
continue;
scoped_ptr<DrawQuad> output_quad;
if (delegated_quad->material != DrawQuad::RENDER_PASS) {
output_quad = delegated_quad->Copy(output_shared_quad_state);
DrawQuad* output_quad = render_pass->CopyFromAndAppendDrawQuad(
delegated_quad, output_shared_quad_state);
output_quad->visible_rect = quad_visible_rect;
} else {
RenderPass::Id delegated_contributing_render_pass_id =
......@@ -461,15 +461,14 @@ void DelegatedRendererLayerImpl::AppendRenderPassQuads(
DCHECK(output_contributing_render_pass_id !=
append_quads_data->render_pass_id);
output_quad = RenderPassDrawQuad::MaterialCast(delegated_quad)->Copy(
RenderPassDrawQuad* output_quad =
render_pass->CopyFromAndAppendRenderPassDrawQuad(
RenderPassDrawQuad::MaterialCast(delegated_quad),
output_shared_quad_state,
output_contributing_render_pass_id).PassAs<DrawQuad>();
output_contributing_render_pass_id);
output_quad->visible_rect = quad_visible_rect;
}
}
if (output_quad)
render_pass->quad_list.push_back(output_quad.Pass());
}
}
......
cc/quads/draw_quad.cc
View file @ d70cc671
......@@ -21,12 +21,6 @@
#include "cc/quads/yuv_video_draw_quad.h"
#include "ui/gfx/quad_f.h"
namespace {
template<typename T> T* TypedCopy(const cc::DrawQuad* other) {
return new T(*T::MaterialCast(other));
}
} // namespace
namespace cc {
DrawQuad::DrawQuad()
......@@ -62,49 +56,6 @@ void DrawQuad::SetAll(const SharedQuadState* shared_quad_state,
DrawQuad::~DrawQuad() {
}
scoped_ptr<DrawQuad> DrawQuad::Copy(
const SharedQuadState* copied_shared_quad_state) const {
scoped_ptr<DrawQuad> copy_quad;
switch (material) {
case CHECKERBOARD:
copy_quad.reset(TypedCopy<CheckerboardDrawQuad>(this));
break;
case DEBUG_BORDER:
copy_quad.reset(TypedCopy<DebugBorderDrawQuad>(this));
break;
case IO_SURFACE_CONTENT:
copy_quad.reset(TypedCopy<IOSurfaceDrawQuad>(this));
break;
case PICTURE_CONTENT:
copy_quad.reset(TypedCopy<PictureDrawQuad>(this));
break;
case TEXTURE_CONTENT:
copy_quad.reset(TypedCopy<TextureDrawQuad>(this));
break;
case SOLID_COLOR:
copy_quad.reset(TypedCopy<SolidColorDrawQuad>(this));
break;
case TILED_CONTENT:
copy_quad.reset(TypedCopy<TileDrawQuad>(this));
break;
case STREAM_VIDEO_CONTENT:
copy_quad.reset(TypedCopy<StreamVideoDrawQuad>(this));
break;
case SURFACE_CONTENT:
copy_quad.reset(TypedCopy<SurfaceDrawQuad>(this));
break;
case YUV_VIDEO_CONTENT:
copy_quad.reset(TypedCopy<YUVVideoDrawQuad>(this));
break;
case RENDER_PASS: // RenderPass quads have their own copy() method.
case INVALID:
LOG(FATAL) << "Invalid DrawQuad material " << material;
break;
}
copy_quad->shared_quad_state = copied_shared_quad_state;
return copy_quad.Pass();
}
scoped_ptr<base::Value> DrawQuad::AsValue() const {
scoped_ptr<base::DictionaryValue> value(new base::DictionaryValue());
value->SetInteger("material", material);
......
cc/quads/draw_quad.h
View file @ d70cc671
......@@ -48,11 +48,6 @@ class CC_EXPORT DrawQuad {
virtual ~DrawQuad();
// TODO(weiliangc): DrawQuad need to be allocated on RenderPass. This function
// need to be moved to RenderPass.
scoped_ptr<DrawQuad> Copy(
const SharedQuadState* copied_shared_quad_state) const;
// TODO(danakj): Chromify or remove these SharedQuadState helpers.
const gfx::Transform& quadTransform() const {
return shared_quad_state->content_to_target_transform;
......
cc/quads/draw_quad_unittest.cc
View file @ d70cc671
......@@ -14,6 +14,7 @@
#include "cc/quads/debug_border_draw_quad.h"
#include "cc/quads/io_surface_draw_quad.h"
#include "cc/quads/picture_draw_quad.h"
#include "cc/quads/render_pass.h"
#include "cc/quads/render_pass_draw_quad.h"
#include "cc/quads/solid_color_draw_quad.h"
#include "cc/quads/stream_video_draw_quad.h"
......@@ -60,7 +61,7 @@ TEST(DrawQuadTest, CopySharedQuadState) {
EXPECT_EQ(blend_mode, copy->blend_mode);
}
scoped_ptr<SharedQuadState> CreateSharedQuadState() {
SharedQuadState* CreateSharedQuadState(RenderPass* render_pass) {
gfx::Transform quad_transform = gfx::Transform(1.0, 0.0, 0.5, 1.0, 0.5, 0.0);
gfx::Size content_bounds(26, 28);
gfx::Rect visible_content_rect(10, 12, 14, 16);
......@@ -70,7 +71,7 @@ scoped_ptr<SharedQuadState> CreateSharedQuadState() {
int sorting_context_id = 65536;
SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode;
scoped_ptr<SharedQuadState> state(new SharedQuadState);
SharedQuadState* state = render_pass->CreateAndAppendSharedQuadState();
state->SetAll(quad_transform,
content_bounds,
visible_content_rect,
......@@ -79,7 +80,7 @@ scoped_ptr<SharedQuadState> CreateSharedQuadState() {
opacity,
blend_mode,
sorting_context_id);
return state.Pass();
return state;
}
void CompareDrawQuad(DrawQuad* quad,
......@@ -94,9 +95,11 @@ void CompareDrawQuad(DrawQuad* quad,
}
#define CREATE_SHARED_STATE() \
scoped_ptr<SharedQuadState> shared_state(CreateSharedQuadState()); \
scoped_ptr<SharedQuadState> copy_shared_state(new SharedQuadState); \
copy_shared_state->CopyFrom(shared_state.get());
scoped_ptr<RenderPass> render_pass = RenderPass::Create(); \
SharedQuadState* shared_state(CreateSharedQuadState(render_pass.get())); \
SharedQuadState* copy_shared_state = \
render_pass->CreateAndAppendSharedQuadState(); \
copy_shared_state->CopyFrom(shared_state);
#define QUAD_DATA \
gfx::Rect quad_rect(30, 40, 50, 60); \
......@@ -105,232 +108,295 @@ void CompareDrawQuad(DrawQuad* quad,
bool ALLOW_UNUSED needs_blending = true;
#define SETUP_AND_COPY_QUAD_NEW(Type, quad) \
scoped_ptr<DrawQuad> copy_new(quad_new->Copy(copy_shared_state.get())); \
CompareDrawQuad(quad_new.get(), copy_new.get(), copy_shared_state.get()); \
const Type* ALLOW_UNUSED copy_quad = Type::MaterialCast(copy_new.get());
DrawQuad* copy_new = \
render_pass->CopyFromAndAppendDrawQuad(quad_new, copy_shared_state); \
CompareDrawQuad(quad_new, copy_new, copy_shared_state); \
const Type* ALLOW_UNUSED copy_quad = Type::MaterialCast(copy_new);
#define SETUP_AND_COPY_QUAD_ALL(Type, quad) \
scoped_ptr<DrawQuad> copy_all(quad_all->Copy(copy_shared_state.get())); \
CompareDrawQuad(quad_all.get(), copy_all.get(), copy_shared_state.get()); \
copy_quad = Type::MaterialCast(copy_all.get());
#define SETUP_AND_COPY_QUAD_NEW_1(Type, quad, a) \
scoped_ptr<DrawQuad> copy_new(quad_new->Copy(copy_shared_state.get(), a)); \
CompareDrawQuad(quad_new.get(), copy_new.get(), copy_shared_state.get()); \
const Type* ALLOW_UNUSED copy_quad = Type::MaterialCast(copy_new.get());
#define SETUP_AND_COPY_QUAD_ALL_1(Type, quad, a) \
scoped_ptr<DrawQuad> copy_all(quad_all->Copy(copy_shared_state.get(), a)); \
CompareDrawQuad(quad_all.get(), copy_all.get(), copy_shared_state.get()); \
copy_quad = Type::MaterialCast(copy_all.get());
DrawQuad* copy_all = \
render_pass->CopyFromAndAppendDrawQuad(quad_all, copy_shared_state); \
CompareDrawQuad(quad_all, copy_all, copy_shared_state); \
copy_quad = Type::MaterialCast(copy_all);
#define SETUP_AND_COPY_QUAD_NEW_RP(Type, quad, a) \
DrawQuad* copy_new = render_pass->CopyFromAndAppendRenderPassDrawQuad( \
quad_new, copy_shared_state, a); \
CompareDrawQuad(quad_new, copy_new, copy_shared_state); \
const Type* ALLOW_UNUSED copy_quad = Type::MaterialCast(copy_new);
#define SETUP_AND_COPY_QUAD_ALL_RP(Type, quad, a) \
DrawQuad* copy_all = render_pass->CopyFromAndAppendRenderPassDrawQuad( \
quad_all, copy_shared_state, a); \
CompareDrawQuad(quad_all, copy_all, copy_shared_state); \
copy_quad = Type::MaterialCast(copy_all);
#define CREATE_QUAD_1_NEW(Type, a) \
scoped_ptr<Type> quad_new(Type::Create()); \
{ \
QUAD_DATA \
quad_new->SetNew(shared_state.get(), quad_rect, a); \
} \
Type* quad_new = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ QUAD_DATA quad_new->SetNew(shared_state, quad_rect, a); } \
SETUP_AND_COPY_QUAD_NEW(Type, quad_new);
#define CREATE_QUAD_1_ALL(Type, a) \
scoped_ptr<Type> quad_all(Type::Create()); \
Type* quad_all = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ \
QUAD_DATA \
quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
quad_visible_rect, needs_blending, a); \
QUAD_DATA quad_all->SetAll(shared_state, \
quad_rect, \
quad_opaque_rect, \
quad_visible_rect, \
needs_blending, \
a); \
} \
SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
#define CREATE_QUAD_2_NEW(Type, a, b) \
scoped_ptr<Type> quad_new(Type::Create()); \
{ \
QUAD_DATA \
quad_new->SetNew(shared_state.get(), quad_rect, a, b); \
} \
Type* quad_new = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ QUAD_DATA quad_new->SetNew(shared_state, quad_rect, a, b); } \
SETUP_AND_COPY_QUAD_NEW(Type, quad_new);
#define CREATE_QUAD_2_ALL(Type, a, b) \
scoped_ptr<Type> quad_all(Type::Create()); \
Type* quad_all = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ \
QUAD_DATA \
quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
quad_visible_rect, needs_blending, a, b); \
QUAD_DATA quad_all->SetAll(shared_state, \
quad_rect, \
quad_opaque_rect, \
quad_visible_rect, \
needs_blending, \
a, \
b); \
} \
SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
#define CREATE_QUAD_3_NEW(Type, a, b, c) \
scoped_ptr<Type> quad_new(Type::Create()); \
{ \
QUAD_DATA \
quad_new->SetNew(shared_state.get(), quad_rect, a, b, c); \
} \
Type* quad_new = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ QUAD_DATA quad_new->SetNew(shared_state, quad_rect, a, b, c); } \
SETUP_AND_COPY_QUAD_NEW(Type, quad_new);
#define CREATE_QUAD_3_ALL(Type, a, b, c) \
scoped_ptr<Type> quad_all(Type::Create()); \
Type* quad_all = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ \
QUAD_DATA \
quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
quad_visible_rect, needs_blending, a, b, c); \
QUAD_DATA quad_all->SetAll(shared_state, \
quad_rect, \
quad_opaque_rect, \
quad_visible_rect, \
needs_blending, \
a, \
b, \
c); \
} \
SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
#define CREATE_QUAD_4_NEW(Type, a, b, c, d) \
scoped_ptr<Type> quad_new(Type::Create()); \
{ \
QUAD_DATA \
quad_new->SetNew(shared_state.get(), quad_rect, a, b, c, d); \
} \
Type* quad_new = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ QUAD_DATA quad_new->SetNew(shared_state, quad_rect, a, b, c, d); } \
SETUP_AND_COPY_QUAD_NEW(Type, quad_new);
#define CREATE_QUAD_4_ALL(Type, a, b, c, d) \
scoped_ptr<Type> quad_all(Type::Create()); \
Type* quad_all = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ \
QUAD_DATA \
quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
quad_visible_rect, needs_blending, a, b, c, d); \
QUAD_DATA quad_all->SetAll(shared_state, \
quad_rect, \
quad_opaque_rect, \
quad_visible_rect, \
needs_blending, \
a, \
b, \
c, \
d); \
} \
SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
#define CREATE_QUAD_5_NEW(Type, a, b, c, d, e) \
scoped_ptr<Type> quad_new(Type::Create()); \
{ \
QUAD_DATA \
quad_new->SetNew(shared_state.get(), quad_rect, a, b, c, d, e); \
} \
Type* quad_new = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ QUAD_DATA quad_new->SetNew(shared_state, quad_rect, a, b, c, d, e); } \
SETUP_AND_COPY_QUAD_NEW(Type, quad_new);
#define CREATE_QUAD_5_ALL(Type, a, b, c, d, e) \
scoped_ptr<Type> quad_all(Type::Create()); \
Type* quad_all = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ \
QUAD_DATA \
quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
quad_visible_rect, needs_blending, a, b, c, d, e); \
QUAD_DATA quad_all->SetAll(shared_state, \
quad_rect, \
quad_opaque_rect, \
quad_visible_rect, \
needs_blending, \
a, \
b, \
c, \
d, \
e); \
} \
SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
#define CREATE_QUAD_5_NEW_1(Type, a, b, c, d, e, copy_a) \
scoped_ptr<Type> quad_new(Type::Create()); \
{ \
QUAD_DATA \
quad_new->SetNew(shared_state.get(), quad_rect, a, b, c, d, e); \
} \
SETUP_AND_COPY_QUAD_NEW_1(Type, quad_new, copy_a);
#define CREATE_QUAD_5_NEW_RP(Type, a, b, c, d, e, copy_a) \
Type* quad_new = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ QUAD_DATA quad_new->SetNew(shared_state, quad_rect, a, b, c, d, e); } \
SETUP_AND_COPY_QUAD_NEW_RP(Type, quad_new, copy_a);
#define CREATE_QUAD_5_ALL_1(Type, a, b, c, d, e, copy_a) \
scoped_ptr<Type> quad_all(Type::Create()); \
#define CREATE_QUAD_5_ALL_RP(Type, a, b, c, d, e, copy_a) \
Type* quad_all = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ \
QUAD_DATA \
quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
quad_visible_rect, needs_blending, a, b, c, d, e); \
QUAD_DATA quad_all->SetAll(shared_state, \
quad_rect, \
quad_opaque_rect, \
quad_visible_rect, \
needs_blending, \
a, \
b, \
c, \
d, \
e); \
} \
SETUP_AND_COPY_QUAD_ALL_1(Type, quad_all, copy_a);
SETUP_AND_COPY_QUAD_ALL_RP(Type, quad_all, copy_a);
#define CREATE_QUAD_6_NEW(Type, a, b, c, d, e, f) \
scoped_ptr<Type> quad_new(Type::Create()); \
{ \
QUAD_DATA \
quad_new->SetNew(shared_state.get(), quad_rect, a, b, c, d, e, f); \
} \
Type* quad_new = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ QUAD_DATA quad_new->SetNew(shared_state, quad_rect, a, b, c, d, e, f); } \
SETUP_AND_COPY_QUAD_NEW(Type, quad_new);
#define CREATE_QUAD_6_ALL(Type, a, b, c, d, e, f) \
scoped_ptr<Type> quad_all(Type::Create()); \
Type* quad_all = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ \
QUAD_DATA \
quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
quad_visible_rect, needs_blending, a, b, c, d, e, f); \
QUAD_DATA quad_all->SetAll(shared_state, \
quad_rect, \
quad_opaque_rect, \
quad_visible_rect, \
needs_blending, \
a, \
b, \
c, \
d, \
e, \
f); \
} \
SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
#define CREATE_QUAD_7_NEW(Type, a, b, c, d, e, f, g) \
scoped_ptr<Type> quad_new(Type::Create()); \
Type* quad_new = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ \
QUAD_DATA \
quad_new->SetNew(shared_state.get(), quad_rect, a, b, c, d, e, f, g); \
QUAD_DATA quad_new->SetNew(shared_state, quad_rect, a, b, c, d, e, f, g); \
} \
SETUP_AND_COPY_QUAD_NEW(Type, quad_new);
#define CREATE_QUAD_7_ALL(Type, a, b, c, d, e, f, g) \
scoped_ptr<Type> quad_all(Type::Create()); \
Type* quad_all = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ \
QUAD_DATA \
quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
quad_visible_rect, needs_blending, \
a, b, c, d, e, f, g); \
QUAD_DATA quad_all->SetAll(shared_state, \
quad_rect, \
quad_opaque_rect, \
quad_visible_rect, \
needs_blending, \
a, \
b, \
c, \
d, \
e, \
f, \
g); \
} \
SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
#define CREATE_QUAD_7_NEW_1(Type, a, b, c, d, e, f, g, copy_a) \
scoped_ptr<Type> quad_new(Type::Create()); \
#define CREATE_QUAD_7_NEW_RP(Type, a, b, c, d, e, f, g, copy_a) \
Type* quad_new = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ \
QUAD_DATA \
quad_new->SetNew(shared_state.get(), quad_rect, a, b, c, d, e, f, g); \
QUAD_DATA quad_new->SetNew(shared_state, quad_rect, a, b, c, d, e, f, g); \
} \
SETUP_AND_COPY_QUAD_NEW_1(Type, quad_new, copy_a);
SETUP_AND_COPY_QUAD_NEW_RP(Type, quad_new, copy_a);
#define CREATE_QUAD_7_ALL_1(Type, a, b, c, d, e, f, g, copy_a) \
scoped_ptr<Type> quad_all(Type::Create()); \
#define CREATE_QUAD_7_ALL_RP(Type, a, b, c, d, e, f, g, copy_a) \
Type* quad_all = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ \
QUAD_DATA \
quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
quad_visible_rect, needs_blending, \
a, b, c, d, e, f, g); \
QUAD_DATA quad_all->SetAll(shared_state, \
quad_rect, \
quad_opaque_rect, \
quad_visible_rect, \
needs_blending, \
a, \
b, \
c, \
d, \
e, \
f, \
g); \
} \
SETUP_AND_COPY_QUAD_ALL_1(Type, quad_all, copy_a);
SETUP_AND_COPY_QUAD_ALL_RP(Type, quad_all, copy_a);
#define CREATE_QUAD_8_NEW(Type, a, b, c, d, e, f, g, h) \
scoped_ptr<Type> quad_new(Type::Create()); \
Type* quad_new = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ \
QUAD_DATA \
quad_new->SetNew(shared_state.get(), quad_rect, a, b, c, d, e, f, g, h); \
QUAD_DATA quad_new->SetNew( \
shared_state, quad_rect, a, b, c, d, e, f, g, h); \
} \
SETUP_AND_COPY_QUAD_NEW(Type, quad_new);
#define CREATE_QUAD_8_ALL(Type, a, b, c, d, e, f, g, h) \
scoped_ptr<Type> quad_all(Type::Create()); \
Type* quad_all = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ \
QUAD_DATA \
quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
quad_visible_rect, needs_blending, \
a, b, c, d, e, f, g, h); \
QUAD_DATA quad_all->SetAll(shared_state, \
quad_rect, \
quad_opaque_rect, \
quad_visible_rect, \
needs_blending, \
a, \
b, \
c, \
d, \
e, \
f, \
g, \
h); \
} \
SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
#define CREATE_QUAD_8_NEW_1(Type, a, b, c, d, e, f, g, h, copy_a) \
scoped_ptr<Type> quad_new(Type::Create()); \
#define CREATE_QUAD_8_NEW_RP(Type, a, b, c, d, e, f, g, h, copy_a) \
Type* quad_new = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ \
QUAD_DATA \
quad_new->SetNew(shared_state.get(), quad_rect, a, b, c, d, e, f, g, h); \
QUAD_DATA quad_new->SetNew( \
shared_state, quad_rect, a, b, c, d, e, f, g, h); \
} \
SETUP_AND_COPY_QUAD_NEW_1(Type, quad_new, copy_a);
SETUP_AND_COPY_QUAD_NEW_RP(Type, quad_new, copy_a);
#define CREATE_QUAD_8_ALL_1(Type, a, b, c, d, e, f, g, h, copy_a) \
scoped_ptr<Type> quad_all(Type::Create()); \
#define CREATE_QUAD_8_ALL_RP(Type, a, b, c, d, e, f, g, h, copy_a) \
Type* quad_all = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ \
QUAD_DATA \
quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
quad_visible_rect, needs_blending, \
a, b, c, d, e, f, g, h); \
QUAD_DATA quad_all->SetAll(shared_state, \
quad_rect, \
quad_opaque_rect, \
quad_visible_rect, \
needs_blending, \
a, \
b, \
c, \
d, \
e, \
f, \
g, \
h); \
} \
SETUP_AND_COPY_QUAD_ALL_1(Type, quad_all, copy_a);
SETUP_AND_COPY_QUAD_ALL_RP(Type, quad_all, copy_a);
#define CREATE_QUAD_9_NEW(Type, a, b, c, d, e, f, g, h, i) \
scoped_ptr<Type> quad_new(Type::Create()); \
Type* quad_new = render_pass->CreateAndAppendDrawQuad<Type>(); \
{ \
QUAD_DATA \
quad_new->SetNew(shared_state.get(), quad_rect, \
a, b, c, d, e, f, g, h, i); \
QUAD_DATA quad_new->SetNew( \
shared_state, quad_rect, a, b, c, d, e, f, g, h, i); \
} \
SETUP_AND_COPY_QUAD_NEW(Type, quad_new);
#define CREATE_QUAD_9_ALL(Type, a, b, c, d, e, f, g, h, i) \
scoped_ptr<Type> quad_all(Type::Create()); \
{ \
QUAD_DATA \
quad_all->SetAll(shared_state.get(), quad_rect, quad_opaque_rect, \
quad_visible_rect, needs_blending, \
a, b, c, d, e, f, g, h, i); \
QUAD_DATA quad_all->SetAll(shared_state, \
quad_rect, \
quad_opaque_rect, \
quad_visible_rect, \
needs_blending, \
a, \
b, \
c, \
d, \
e, \
f, \
g, \
h, \
i); \
} \
SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
......@@ -411,7 +477,7 @@ TEST(DrawQuadTest, CopyRenderPassDrawQuad) {
RenderPass::Id copied_render_pass_id(235, 11);
CREATE_SHARED_STATE();
CREATE_QUAD_8_NEW_1(RenderPassDrawQuad,
CREATE_QUAD_8_NEW_RP(RenderPassDrawQuad,
visible_rect,
render_pass_id,
is_replica,
......@@ -432,7 +498,7 @@ TEST(DrawQuadTest, CopyRenderPassDrawQuad) {
EXPECT_EQ(filters, copy_quad->filters);
EXPECT_EQ(background_filters, copy_quad->background_filters);
CREATE_QUAD_7_ALL_1(RenderPassDrawQuad,
CREATE_QUAD_7_ALL_RP(RenderPassDrawQuad,
render_pass_id,
is_replica,
mask_resource_id,
......@@ -709,7 +775,7 @@ TEST_F(DrawQuadIteratorTest, CheckerboardDrawQuad) {
CREATE_SHARED_STATE();
CREATE_QUAD_2_NEW(CheckerboardDrawQuad, visible_rect, color);
EXPECT_EQ(0, IterateAndCount(quad_new.get()));
EXPECT_EQ(0, IterateAndCount(quad_new));
}
TEST_F(DrawQuadIteratorTest, DebugBorderDrawQuad) {
......@@ -719,7 +785,7 @@ TEST_F(DrawQuadIteratorTest, DebugBorderDrawQuad) {
CREATE_SHARED_STATE();
CREATE_QUAD_3_NEW(DebugBorderDrawQuad, visible_rect, color, width);
EXPECT_EQ(0, IterateAndCount(quad_new.get()));
EXPECT_EQ(0, IterateAndCount(quad_new));
}
TEST_F(DrawQuadIteratorTest, IOSurfaceDrawQuad) {
......@@ -737,7 +803,7 @@ TEST_F(DrawQuadIteratorTest, IOSurfaceDrawQuad) {
resource_id,
orientation);
EXPECT_EQ(resource_id, quad_new->io_surface_resource_id);
EXPECT_EQ(1, IterateAndCount(quad_new.get()));
EXPECT_EQ(1, IterateAndCount(quad_new));
EXPECT_EQ(resource_id + 1, quad_new->io_surface_resource_id);
}
......@@ -757,7 +823,7 @@ TEST_F(DrawQuadIteratorTest, RenderPassDrawQuad) {
RenderPass::Id copied_render_pass_id(235, 11);
CREATE_SHARED_STATE();
CREATE_QUAD_8_NEW_1(RenderPassDrawQuad,
CREATE_QUAD_8_NEW_RP(RenderPassDrawQuad,
visible_rect,
render_pass_id,
is_replica,
......@@ -768,10 +834,10 @@ TEST_F(DrawQuadIteratorTest, RenderPassDrawQuad) {
background_filters,
copied_render_pass_id);
EXPECT_EQ(mask_resource_id, quad_new->mask_resource_id);
EXPECT_EQ(1, IterateAndCount(quad_new.get()));
EXPECT_EQ(1, IterateAndCount(quad_new));
EXPECT_EQ(mask_resource_id + 1, quad_new->mask_resource_id);
quad_new->mask_resource_id = 0;
EXPECT_EQ(0, IterateAndCount(quad_new.get()));
EXPECT_EQ(0, IterateAndCount(quad_new));
EXPECT_EQ(0u, quad_new->mask_resource_id);
}
......@@ -783,7 +849,7 @@ TEST_F(DrawQuadIteratorTest, SolidColorDrawQuad) {
CREATE_SHARED_STATE();
CREATE_QUAD_3_NEW(
SolidColorDrawQuad, visible_rect, color, force_anti_aliasing_off);
EXPECT_EQ(0, IterateAndCount(quad_new.get()));
EXPECT_EQ(0, IterateAndCount(quad_new));
}
TEST_F(DrawQuadIteratorTest, StreamVideoDrawQuad) {
......@@ -796,7 +862,7 @@ TEST_F(DrawQuadIteratorTest, StreamVideoDrawQuad) {
CREATE_QUAD_4_NEW(
StreamVideoDrawQuad, opaque_rect, visible_rect, resource_id, matrix);
EXPECT_EQ(resource_id, quad_new->resource_id);
EXPECT_EQ(1, IterateAndCount(quad_new.get()));
EXPECT_EQ(1, IterateAndCount(quad_new));
EXPECT_EQ(resource_id + 1, quad_new->resource_id);
}
......@@ -806,7 +872,7 @@ TEST_F(DrawQuadIteratorTest, SurfaceDrawQuad) {
CREATE_SHARED_STATE();
CREATE_QUAD_2_NEW(SurfaceDrawQuad, visible_rect, surface_id);
EXPECT_EQ(0, IterateAndCount(quad_new.get()));
EXPECT_EQ(0, IterateAndCount(quad_new));
}
TEST_F(DrawQuadIteratorTest, TextureDrawQuad) {
......@@ -831,7 +897,7 @@ TEST_F(DrawQuadIteratorTest, TextureDrawQuad) {
vertex_opacity,
flipped);
EXPECT_EQ(resource_id, quad_new->resource_id);
EXPECT_EQ(1, IterateAndCount(quad_new.get()));
EXPECT_EQ(1, IterateAndCount(quad_new));
EXPECT_EQ(resource_id + 1, quad_new->resource_id);
}
......@@ -852,7 +918,7 @@ TEST_F(DrawQuadIteratorTest, TileDrawQuad) {
texture_size,
swizzle_contents);
EXPECT_EQ(resource_id, quad_new->resource_id);
EXPECT_EQ(1, IterateAndCount(quad_new.get()));
EXPECT_EQ(1, IterateAndCount(quad_new));
EXPECT_EQ(resource_id + 1, quad_new->resource_id);
}
......@@ -882,7 +948,7 @@ TEST_F(DrawQuadIteratorTest, YUVVideoDrawQuad) {
EXPECT_EQ(v_plane_resource_id, quad_new->v_plane_resource_id);
EXPECT_EQ(a_plane_resource_id, quad_new->a_plane_resource_id);
EXPECT_EQ(color_space, quad_new->color_space);
EXPECT_EQ(4, IterateAndCount(quad_new.get()));
EXPECT_EQ(4, IterateAndCount(quad_new));
EXPECT_EQ(y_plane_resource_id + 1, quad_new->y_plane_resource_id);
EXPECT_EQ(u_plane_resource_id + 1, quad_new->u_plane_resource_id);
EXPECT_EQ(v_plane_resource_id + 1, quad_new->v_plane_resource_id);
......@@ -910,7 +976,7 @@ TEST_F(DrawQuadIteratorTest, DISABLED_PictureDrawQuad) {
content_rect,
contents_scale,
picture_pile);
EXPECT_EQ(0, IterateAndCount(quad_new.get()));
EXPECT_EQ(0, IterateAndCount(quad_new));
}
} // namespace
......
cc/quads/render_pass.cc
View file @ d70cc671
......@@ -107,12 +107,13 @@ void RenderPass::CopyAll(const ScopedPtrVector<RenderPass>& in,
if (quad->material == DrawQuad::RENDER_PASS) {
const RenderPassDrawQuad* pass_quad =
RenderPassDrawQuad::MaterialCast(quad);
copy_pass->quad_list.push_back(
pass_quad->Copy(copy_pass->shared_quad_state_list[sqs_i],
pass_quad->render_pass_id).PassAs<DrawQuad>());
copy_pass->CopyFromAndAppendRenderPassDrawQuad(
pass_quad,
copy_pass->shared_quad_state_list[sqs_i],
pass_quad->render_pass_id);
} else {
copy_pass->quad_list.push_back(source->quad_list[i]->Copy(
copy_pass->shared_quad_state_list[sqs_i]));
copy_pass->CopyFromAndAppendDrawQuad(
quad, copy_pass->shared_quad_state_list[sqs_i]);
}
}
out->push_back(copy_pass.Pass());
......
cc/quads/render_pass_draw_quad.cc
View file @ d70cc671
......@@ -24,16 +24,6 @@ scoped_ptr<RenderPassDrawQuad> RenderPassDrawQuad::Create() {
return make_scoped_ptr(new RenderPassDrawQuad);
}
scoped_ptr<RenderPassDrawQuad> RenderPassDrawQuad::Copy(
const SharedQuadState* copied_shared_quad_state,
RenderPass::Id copied_render_pass_id) const {
scoped_ptr<RenderPassDrawQuad> copy_quad(
new RenderPassDrawQuad(*MaterialCast(this)));
copy_quad->shared_quad_state = copied_shared_quad_state;
copy_quad->render_pass_id = copied_render_pass_id;
return copy_quad.Pass();
}
void RenderPassDrawQuad::SetNew(
const SharedQuadState* shared_quad_state,
const gfx::Rect& rect,
......
cc/quads/render_pass_draw_quad.h
View file @ d70cc671
......@@ -44,10 +44,6 @@ class CC_EXPORT RenderPassDrawQuad : public DrawQuad {
const FilterOperations& filters,
const FilterOperations& background_filters);
scoped_ptr<RenderPassDrawQuad> Copy(
const SharedQuadState* copied_shared_quad_state,
RenderPass::Id copied_render_pass_id) const;
RenderPass::Id render_pass_id;
bool is_replica;
ResourceProvider::ResourceId mask_resource_id;
......
cc/surfaces/surface_aggregator.cc
View file @ d70cc671
......@@ -248,12 +248,13 @@ void SurfaceAggregator::CopyQuadsToPass(
RenderPass::Id remapped_pass_id =
RemapPassId(original_pass_id, surface_id);
dest_pass->quad_list.push_back(
pass_quad->Copy(dest_pass->shared_quad_state_list.back(),
remapped_pass_id).PassAs<DrawQuad>());
dest_pass->CopyFromAndAppendRenderPassDrawQuad(
pass_quad,
dest_pass->shared_quad_state_list.back(),
remapped_pass_id);
} else {
dest_pass->quad_list.push_back(
quad->Copy(dest_pass->shared_quad_state_list.back()));
dest_pass->CopyFromAndAppendDrawQuad(
quad, dest_pass->shared_quad_state_list.back());
}
}
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment