chromium/src
0
Fork 0
Code Activity

cc: Make the DrawQuad subclasses into a struct-like classes.

Browse Source 
I've replaced the create() and constructor on each class with a SetNew() method:

  void SetNew(const SharedQuadState* shared_quad_state,
              gfx::Rect rect,
              ...);

This method sets everything in the base class, based on the subclass'
interpretation of the minimal parameters given to it. This is used when
creating a new quad of this type - hence the name. The "..." represents
all the quad-type-specific arguments.

I've also added a new SetAll() method, that takes all of the data held by this
quad type, and simply passes on the appropriate things to the super class:

  void SetAll(const SharedQuadState* shared_quad_state,
              gfx::Rect rect,
              gfx::Rect opaque_rect,
              gfx::Rect visible_rect,
              bool needs_blending,
              ...);

This method is used for deserializing, or other cases where you have all the
data for the quad well defined, and want to set every field at once. The
"..." represents all the quad-type-specific arguments.

Added tests for SetAll() in cc_unittests:DrawQuadTest.*

TBR=aelias
BUG=152337

Review URL: https://chromiumcodereview.appspot.com/11411050

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@168903 0039d316-1c4b-4281-b951-d872f2087c98
This commit is contained in:
danakj@chromium.org
2012-11-20 23:06:26 +00:00
parent 62669313d2
commit c22418befb
45 changed files with 1184 additions and 610 deletions

42
cc/checkerboard_draw_quad.cc

@ -8,24 +8,38 @@
namespace cc {
scoped_ptr<CheckerboardDrawQuad> CheckerboardDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, SkColor color)
{
return make_scoped_ptr(new CheckerboardDrawQuad(sharedQuadState, quadRect, color));
CheckerboardDrawQuad::CheckerboardDrawQuad() : color(0) {}
scoped_ptr<CheckerboardDrawQuad> CheckerboardDrawQuad::Create() {
return make_scoped_ptr(new CheckerboardDrawQuad);
}
CheckerboardDrawQuad::CheckerboardDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, SkColor color)
: m_color(color)
{
gfx::Rect opaqueRect = SkColorGetA(m_color) == 255 ? quadRect : gfx::Rect();
gfx::Rect visibleRect = quadRect;
bool needsBlending = false;
DrawQuad::SetAll(sharedQuadState, DrawQuad::CHECKERBOARD, quadRect, opaqueRect, visibleRect, needsBlending);
void CheckerboardDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
SkColor color) {
gfx::Rect opaque_rect = SkColorGetA(color) == 255 ? rect : gfx::Rect();
gfx::Rect visible_rect = rect;
bool needs_blending = false;
DrawQuad::SetAll(shared_quad_state, DrawQuad::CHECKERBOARD, rect, opaque_rect,
visible_rect, needs_blending);
this->color = color;
}
const CheckerboardDrawQuad* CheckerboardDrawQuad::materialCast(const DrawQuad* quad)
{
DCHECK(quad->material == DrawQuad::CHECKERBOARD);
return static_cast<const CheckerboardDrawQuad*>(quad);
void CheckerboardDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Rect visible_rect,
bool needs_blending,
SkColor color) {
DrawQuad::SetAll(shared_quad_state, DrawQuad::CHECKERBOARD, rect, opaque_rect,
visible_rect, needs_blending);
this->color = color;
}
const CheckerboardDrawQuad* CheckerboardDrawQuad::MaterialCast(
const DrawQuad* quad) {
DCHECK(quad->material == DrawQuad::CHECKERBOARD);
return static_cast<const CheckerboardDrawQuad*>(quad);
}
} // namespace cc

23
cc/checkerboard_draw_quad.h

@ -13,16 +13,25 @@
namespace cc {
class CC_EXPORT CheckerboardDrawQuad : public DrawQuad {
public:
static scoped_ptr<CheckerboardDrawQuad> create(const SharedQuadState*, const gfx::Rect&, SkColor);
public:
static scoped_ptr<CheckerboardDrawQuad> Create();
SkColor color() const { return m_color; };
void SetNew(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
SkColor color);
static const CheckerboardDrawQuad* materialCast(const DrawQuad*);
private:
CheckerboardDrawQuad(const SharedQuadState*, const gfx::Rect&, SkColor);
void SetAll(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Rect visible_rect,
bool needs_blending,
SkColor color);
SkColor m_color;
SkColor color;
static const CheckerboardDrawQuad* MaterialCast(const DrawQuad*);
private:
CheckerboardDrawQuad();
};
}

50
cc/debug_border_draw_quad.cc

@ -8,25 +8,45 @@
namespace cc {
scoped_ptr<DebugBorderDrawQuad> DebugBorderDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, SkColor color, int width)
{
return make_scoped_ptr(new DebugBorderDrawQuad(sharedQuadState, quadRect, color, width));
DebugBorderDrawQuad::DebugBorderDrawQuad()
: color(0),
width(0) {
}
DebugBorderDrawQuad::DebugBorderDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, SkColor color, int width)
: m_color(color)
, m_width(width)
{
gfx::Rect opaqueRect;
gfx::Rect visibleRect = quadRect;
bool needsBlending = SkColorGetA(m_color) < 255;
DrawQuad::SetAll(sharedQuadState, DrawQuad::DEBUG_BORDER, quadRect, opaqueRect, visibleRect, needsBlending);
scoped_ptr<DebugBorderDrawQuad> DebugBorderDrawQuad::Create() {
return make_scoped_ptr(new DebugBorderDrawQuad);
}
const DebugBorderDrawQuad* DebugBorderDrawQuad::materialCast(const DrawQuad* quad)
{
DCHECK(quad->material == DrawQuad::DEBUG_BORDER);
return static_cast<const DebugBorderDrawQuad*>(quad);
void DebugBorderDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
SkColor color,
int width) {
gfx::Rect opaque_rect;
gfx::Rect visible_rect = rect;
bool needs_blending = SkColorGetA(color) < 255;
DrawQuad::SetAll(shared_quad_state, DrawQuad::DEBUG_BORDER, rect, opaque_rect,
visible_rect, needs_blending);
this->color = color;
this->width = width;
}
void DebugBorderDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Rect visible_rect,
bool needs_blending,
SkColor color,
int width) {
DrawQuad::SetAll(shared_quad_state, DrawQuad::DEBUG_BORDER, rect, opaque_rect,
visible_rect, needs_blending);
this->color = color;
this->width = width;
}
const DebugBorderDrawQuad* DebugBorderDrawQuad::MaterialCast(
const DrawQuad* quad) {
DCHECK(quad->material == DrawQuad::DEBUG_BORDER);
return static_cast<const DebugBorderDrawQuad*>(quad);
}
} // namespace cc

28
cc/debug_border_draw_quad.h

@ -13,18 +13,28 @@
namespace cc {
class CC_EXPORT DebugBorderDrawQuad : public DrawQuad {
public:
static scoped_ptr<DebugBorderDrawQuad> create(const SharedQuadState*, const gfx::Rect&, SkColor, int width);
public:
static scoped_ptr<DebugBorderDrawQuad> Create();
SkColor color() const { return m_color; };
int width() const { return m_width; }
void SetNew(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
SkColor color,
int width);
static const DebugBorderDrawQuad* materialCast(const DrawQuad*);
private:
DebugBorderDrawQuad(const SharedQuadState*, const gfx::Rect&, SkColor, int width);
void SetAll(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Rect visible_rect,
bool needs_blending,
SkColor color,
int width);
SkColor m_color;
int m_width;
SkColor color;
int width;
static const DebugBorderDrawQuad* MaterialCast(const DrawQuad*);
private:
DebugBorderDrawQuad();
};
}

4
cc/delegated_renderer_layer_impl.cc

@ -163,11 +163,11 @@ void DelegatedRendererLayerImpl::appendRenderPassQuads(QuadSink& quadSink, Appen
if (quad->material != DrawQuad::RENDER_PASS)
copyQuad = quad->Copy(copiedSharedQuadState);
else {
RenderPass::Id contributingDelegatedRenderPassId = RenderPassDrawQuad::materialCast(quad)->renderPassId();
RenderPass::Id contributingDelegatedRenderPassId = RenderPassDrawQuad::MaterialCast(quad)->render_pass_id;
RenderPass::Id contributingRenderPassId = convertDelegatedRenderPassId(contributingDelegatedRenderPassId);
DCHECK(contributingRenderPassId != appendQuadsData.renderPassId);
copyQuad = RenderPassDrawQuad::materialCast(quad)->copy(copiedSharedQuadState, contributingRenderPassId).PassAs<DrawQuad>();
copyQuad = RenderPassDrawQuad::MaterialCast(quad)->Copy(copiedSharedQuadState, contributingRenderPassId).PassAs<DrawQuad>();
}
DCHECK(copyQuad.get());

28
cc/delegated_renderer_layer_impl_unittest.cc

@ -79,7 +79,8 @@ static SolidColorDrawQuad* addQuad(TestRenderPass* pass, gfx::Rect rect, SkColor
MockQuadCuller quadSink(pass->quadList(), pass->sharedQuadStateList());
AppendQuadsData data(pass->id());
SharedQuadState* sharedState = quadSink.useSharedQuadState(SharedQuadState::create(WebTransformationMatrix(), rect, rect, 1));
scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::create(sharedState, rect, color);
scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
quad->SetNew(sharedState, rect, color);
SolidColorDrawQuad* quadPtr = quad.get();
quadSink.append(quad.PassAs<DrawQuad>(), data);
return quadPtr;
@ -91,7 +92,8 @@ static void addRenderPassQuad(TestRenderPass* toPass, TestRenderPass* contributi
AppendQuadsData data(toPass->id());
gfx::Rect outputRect = contributingPass->outputRect();
SharedQuadState* sharedState = quadSink.useSharedQuadState(SharedQuadState::create(WebTransformationMatrix(), outputRect, outputRect, 1));
scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::create(sharedState, outputRect, contributingPass->id(), false, 0, outputRect, 0, 0, 0, 0);
scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
quad->SetNew(sharedState, outputRect, contributingPass->id(), false, 0, outputRect, 0, 0, 0, 0);
quadSink.append(quad.PassAs<DrawQuad>(), data);
}
@ -403,10 +405,24 @@ public:
MockQuadCuller quadSink(pass->quadList(), pass->sharedQuadStateList());
AppendQuadsData data(pass->id());
SharedQuadState* sharedState = quadSink.useSharedQuadState(SharedQuadState::create(WebTransformationMatrix(), passRect, passRect, 1));
quadSink.append(SolidColorDrawQuad::create(sharedState, gfx::Rect(0, 0, 10, 10), 1u).PassAs<DrawQuad>(), data);
quadSink.append(SolidColorDrawQuad::create(sharedState, gfx::Rect(0, 10, 10, 10), 2u).PassAs<DrawQuad>(), data);
quadSink.append(SolidColorDrawQuad::create(sharedState, gfx::Rect(10, 0, 10, 10), 3u).PassAs<DrawQuad>(), data);
quadSink.append(SolidColorDrawQuad::create(sharedState, gfx::Rect(10, 10, 10, 10), 4u).PassAs<DrawQuad>(), data);
scoped_ptr<SolidColorDrawQuad> colorQuad;
colorQuad = SolidColorDrawQuad::Create();
colorQuad->SetNew(sharedState, gfx::Rect(0, 0, 10, 10), 1u);
quadSink.append(colorQuad.PassAs<DrawQuad>(), data);
colorQuad = SolidColorDrawQuad::Create();
colorQuad->SetNew(sharedState, gfx::Rect(0, 10, 10, 10), 2u);
quadSink.append(colorQuad.PassAs<DrawQuad>(), data);
colorQuad = SolidColorDrawQuad::Create();
colorQuad->SetNew(sharedState, gfx::Rect(10, 0, 10, 10), 3u);
quadSink.append(colorQuad.PassAs<DrawQuad>(), data);
colorQuad = SolidColorDrawQuad::Create();
colorQuad->SetNew(sharedState, gfx::Rect(10, 10, 10, 10), 4u);
quadSink.append(colorQuad.PassAs<DrawQuad>(), data);
delegatedRendererLayer->setRenderPasses(delegatedRenderPasses);
// The RenderPasses should be taken by the layer.

2
cc/draw_quad.cc

@ -18,7 +18,7 @@
namespace {
template<typename T> T* TypedCopy(const cc::DrawQuad* other) {
return new T(*T::materialCast(other));
return new T(*T::MaterialCast(other));
}
}

375
cc/draw_quad_unittest.cc

@ -71,82 +71,162 @@ void compareDrawQuad(DrawQuad* quad, DrawQuad* copy, SharedQuadState* copyShared
#define QUAD_DATA \
gfx::Rect quadRect(30, 40, 50, 60); \
gfx::Rect quadVisibleRect(40, 50, 30, 20);
gfx::Rect quadVisibleRect(40, 50, 30, 20); \
gfx::Rect quadOpaqueRect(60, 55, 10, 10); \
bool needsBlending = true;
#define SETUP_AND_COPY_QUAD(Type, quad) \
quad->visible_rect = quadVisibleRect; \
scoped_ptr<DrawQuad> copy(quad->Copy(copySharedState.get())); \
compareDrawQuad(quad.get(), copy.get(), copySharedState.get()); \
const Type* copyQuad = Type::materialCast(copy.get());
#define SETUP_AND_COPY_QUAD_NEW(Type, quad) \
scoped_ptr<DrawQuad> copyNew(quadNew->Copy(copySharedState.get())); \
compareDrawQuad(quadNew.get(), copyNew.get(), copySharedState.get()); \
const Type* copyQuad = Type::MaterialCast(copyNew.get());
#define SETUP_AND_COPY_QUAD_1(Type, quad, a) \
quad->visible_rect = quadVisibleRect; \
scoped_ptr<DrawQuad> copy(quad->copy(copySharedState.get(), a)); \
compareDrawQuad(quad.get(), copy.get(), copySharedState.get()); \
const Type* copyQuad = Type::materialCast(copy.get());
#define SETUP_AND_COPY_QUAD_ALL(Type, quad) \
scoped_ptr<DrawQuad> copyAll(quadAll->Copy(copySharedState.get())); \
compareDrawQuad(quadAll.get(), copyAll.get(), copySharedState.get()); \
copyQuad = Type::MaterialCast(copyAll.get());
#define CREATE_QUAD_0(Type) \
QUAD_DATA \
scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect)); \
SETUP_AND_COPY_QUAD(Type, quad); \
UNUSED_PARAM(copyQuad);
#define SETUP_AND_COPY_QUAD_NEW_1(Type, quad, a) \
scoped_ptr<DrawQuad> copyNew(quadNew->Copy(copySharedState.get(), a)); \
compareDrawQuad(quadNew.get(), copyNew.get(), copySharedState.get()); \
const Type* copyQuad = Type::MaterialCast(copyNew.get());
#define CREATE_QUAD_1(Type, a) \
QUAD_DATA \
scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a)); \
SETUP_AND_COPY_QUAD(Type, quad);
#define SETUP_AND_COPY_QUAD_ALL_1(Type, quad, a) \
scoped_ptr<DrawQuad> copyAll(quadAll->Copy(copySharedState.get(), a)); \
compareDrawQuad(quadAll.get(), copyAll.get(), copySharedState.get()); \
copyQuad = Type::MaterialCast(copyAll.get());
#define CREATE_QUAD_2(Type, a, b) \
QUAD_DATA \
scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b)); \
SETUP_AND_COPY_QUAD(Type, quad);
#define CREATE_QUAD_1_NEW(Type, a) \
scoped_ptr<Type> quadNew(Type::Create()); \
{ QUAD_DATA \
quadNew->SetNew(sharedState.get(), quadRect, a); } \
SETUP_AND_COPY_QUAD_NEW(Type, quadNew);
#define CREATE_QUAD_3(Type, a, b, c) \
QUAD_DATA \
scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c)); \
SETUP_AND_COPY_QUAD(Type, quad);
#define CREATE_QUAD_1_ALL(Type, a) \
scoped_ptr<Type> quadAll(Type::Create()); \
{ QUAD_DATA \
quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a); } \
SETUP_AND_COPY_QUAD_ALL(Type, quadAll);
#define CREATE_QUAD_4(Type, a, b, c, d) \
QUAD_DATA \
scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d)); \
SETUP_AND_COPY_QUAD(Type, quad);
#define CREATE_QUAD_2_NEW(Type, a, b) \
scoped_ptr<Type> quadNew(Type::Create()); \
{ QUAD_DATA \
quadNew->SetNew(sharedState.get(), quadRect, a, b); } \
SETUP_AND_COPY_QUAD_NEW(Type, quadNew);
#define CREATE_QUAD_5(Type, a, b, c, d, e) \
QUAD_DATA \
scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e)); \
SETUP_AND_COPY_QUAD(Type, quad);
#define CREATE_QUAD_2_ALL(Type, a, b) \
scoped_ptr<Type> quadAll(Type::Create()); \
{ QUAD_DATA \
quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b); } \
SETUP_AND_COPY_QUAD_ALL(Type, quadAll);
#define CREATE_QUAD_6(Type, a, b, c, d, e, f) \
QUAD_DATA \
scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f)); \
SETUP_AND_COPY_QUAD(Type, quad);
#define CREATE_QUAD_3_NEW(Type, a, b, c) \
scoped_ptr<Type> quadNew(Type::Create()); \
{ QUAD_DATA \
quadNew->SetNew(sharedState.get(), quadRect, a, b, c); } \
SETUP_AND_COPY_QUAD_NEW(Type, quadNew);
#define CREATE_QUAD_7(Type, a, b, c, d, e, f, g) \
QUAD_DATA \
scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g)); \
SETUP_AND_COPY_QUAD(Type, quad);
#define CREATE_QUAD_3_ALL(Type, a, b, c) \
scoped_ptr<Type> quadAll(Type::Create()); \
{ QUAD_DATA \
quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c); } \
SETUP_AND_COPY_QUAD_ALL(Type, quadAll);
#define CREATE_QUAD_8(Type, a, b, c, d, e, f, g, h) \
QUAD_DATA \
scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g, h)); \
SETUP_AND_COPY_QUAD(Type, quad);
#define CREATE_QUAD_4_NEW(Type, a, b, c, d) \
scoped_ptr<Type> quadNew(Type::Create()); \
{ QUAD_DATA \
quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d); } \
SETUP_AND_COPY_QUAD_NEW(Type, quadNew);
#define CREATE_QUAD_8_1(Type, a, b, c, d, e, f, g, h, copyA) \
QUAD_DATA \
scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g, h)); \
SETUP_AND_COPY_QUAD_1(Type, quad, copyA);
#define CREATE_QUAD_4_ALL(Type, a, b, c, d) \
scoped_ptr<Type> quadAll(Type::Create()); \
{ QUAD_DATA \
quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d); } \
SETUP_AND_COPY_QUAD_ALL(Type, quadAll);
#define CREATE_QUAD_9(Type, a, b, c, d, e, f, g, h, i) \
QUAD_DATA \
scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g, h, i)); \
SETUP_AND_COPY_QUAD(Type, quad);
#define CREATE_QUAD_5_NEW(Type, a, b, c, d, e) \
scoped_ptr<Type> quadNew(Type::Create()); \
{ QUAD_DATA \
quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d, e); } \
SETUP_AND_COPY_QUAD_NEW(Type, quadNew);
#define CREATE_QUAD_5_ALL(Type, a, b, c, d, e) \
scoped_ptr<Type> quadAll(Type::Create()); \
{ QUAD_DATA \
quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d, e); } \
SETUP_AND_COPY_QUAD_ALL(Type, quadAll);
#define CREATE_QUAD_6_NEW(Type, a, b, c, d, e, f) \
scoped_ptr<Type> quadNew(Type::Create()); \
{ QUAD_DATA \
quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d, e, f); } \
SETUP_AND_COPY_QUAD_NEW(Type, quadNew);
#define CREATE_QUAD_6_ALL(Type, a, b, c, d, e, f) \
scoped_ptr<Type> quadAll(Type::Create()); \
{ QUAD_DATA \
quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d, e, f); } \
SETUP_AND_COPY_QUAD_ALL(Type, quadAll);
#define CREATE_QUAD_7_NEW(Type, a, b, c, d, e, f, g) \
scoped_ptr<Type> quadNew(Type::Create()); \
{ QUAD_DATA \
quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d, e, f, g); } \
SETUP_AND_COPY_QUAD_NEW(Type, quadNew);
#define CREATE_QUAD_7_ALL(Type, a, b, c, d, e, f, g) \
scoped_ptr<Type> quadAll(Type::Create()); \
{ QUAD_DATA \
quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d, e, f, g); } \
SETUP_AND_COPY_QUAD_ALL(Type, quadAll);
#define CREATE_QUAD_8_NEW(Type, a, b, c, d, e, f, g, h) \
scoped_ptr<Type> quadNew(Type::Create()); \
{ QUAD_DATA \
quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d, e, f, g, h); } \
SETUP_AND_COPY_QUAD_NEW(Type, quadNew);
#define CREATE_QUAD_8_ALL(Type, a, b, c, d, e, f, g, h) \
scoped_ptr<Type> quadAll(Type::Create()); \
{ QUAD_DATA \
quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d, e, f, g, h); } \
SETUP_AND_COPY_QUAD_ALL(Type, quadAll);
#define CREATE_QUAD_8_NEW_1(Type, a, b, c, d, e, f, g, h, copyA) \
scoped_ptr<Type> quadNew(Type::Create()); \
{ QUAD_DATA \
quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d, e, f, g, h); } \
SETUP_AND_COPY_QUAD_NEW_1(Type, quadNew, copyA);
#define CREATE_QUAD_8_ALL_1(Type, a, b, c, d, e, f, g, h, copyA) \
scoped_ptr<Type> quadAll(Type::Create()); \
{ QUAD_DATA \
quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d, e, f, g, h); } \
SETUP_AND_COPY_QUAD_ALL_1(Type, quadAll, copyA);
#define CREATE_QUAD_9_NEW(Type, a, b, c, d, e, f, g, h, i) \
scoped_ptr<Type> quadNew(Type::Create()); \
{ QUAD_DATA \
quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d, e, f, g, h, i); } \
SETUP_AND_COPY_QUAD_NEW(Type, quadNew);
#define CREATE_QUAD_9_ALL(Type, a, b, c, d, e, f, g, h, i) \
scoped_ptr<Type> quadAll(Type::Create()); \
{ QUAD_DATA \
quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d, e, f, g, h, i); } \
SETUP_AND_COPY_QUAD_ALL(Type, quadAll);
TEST(DrawQuadTest, copyCheckerboardDrawQuad)
{
SkColor color = 0xfabb0011;
CREATE_SHARED_STATE();
CREATE_QUAD_1(CheckerboardDrawQuad, color);
EXPECT_EQ(color, copyQuad->color());
CREATE_QUAD_1_NEW(CheckerboardDrawQuad, color);
EXPECT_EQ(DrawQuad::CHECKERBOARD, copyQuad->material);
EXPECT_EQ(color, copyQuad->color);
CREATE_QUAD_1_ALL(CheckerboardDrawQuad, color);
EXPECT_EQ(DrawQuad::CHECKERBOARD, copyQuad->material);
EXPECT_EQ(color, copyQuad->color);
}
TEST(DrawQuadTest, copyDebugBorderDrawQuad)
@ -154,9 +234,16 @@ TEST(DrawQuadTest, copyDebugBorderDrawQuad)
SkColor color = 0xfabb0011;
int width = 99;
CREATE_SHARED_STATE();
CREATE_QUAD_2(DebugBorderDrawQuad, color, width);
EXPECT_EQ(color, copyQuad->color());
EXPECT_EQ(width, copyQuad->width());
CREATE_QUAD_2_NEW(DebugBorderDrawQuad, color, width);
EXPECT_EQ(DrawQuad::DEBUG_BORDER, copyQuad->material);
EXPECT_EQ(color, copyQuad->color);
EXPECT_EQ(width, copyQuad->width);
CREATE_QUAD_2_ALL(DebugBorderDrawQuad, color, width);
EXPECT_EQ(DrawQuad::DEBUG_BORDER, copyQuad->material);
EXPECT_EQ(color, copyQuad->color);
EXPECT_EQ(width, copyQuad->width);
}
TEST(DrawQuadTest, copyIOSurfaceDrawQuad)
@ -164,14 +251,21 @@ TEST(DrawQuadTest, copyIOSurfaceDrawQuad)
gfx::Rect opaqueRect(3, 7, 10, 12);
gfx::Size size(58, 95);
unsigned textureId = 72;
IOSurfaceDrawQuad::Orientation orientation = IOSurfaceDrawQuad::Unflipped;
IOSurfaceDrawQuad::Orientation orientation = IOSurfaceDrawQuad::UNFLIPPED;
CREATE_SHARED_STATE();
CREATE_QUAD_4(IOSurfaceDrawQuad, opaqueRect, size, textureId, orientation);
CREATE_QUAD_4_NEW(IOSurfaceDrawQuad, opaqueRect, size, textureId, orientation);
EXPECT_EQ(DrawQuad::IO_SURFACE_CONTENT, copyQuad->material);
EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect);
EXPECT_EQ(size, copyQuad->ioSurfaceSize());
EXPECT_EQ(textureId, copyQuad->ioSurfaceTextureId());
EXPECT_EQ(orientation, copyQuad->orientation());
EXPECT_EQ(size, copyQuad->io_surface_size);
EXPECT_EQ(textureId, copyQuad->io_surface_texture_id);
EXPECT_EQ(orientation, copyQuad->orientation);
CREATE_QUAD_3_ALL(IOSurfaceDrawQuad, size, textureId, orientation);
EXPECT_EQ(DrawQuad::IO_SURFACE_CONTENT, copyQuad->material);
EXPECT_EQ(size, copyQuad->io_surface_size);
EXPECT_EQ(textureId, copyQuad->io_surface_texture_id);
EXPECT_EQ(orientation, copyQuad->orientation);
}
TEST(DrawQuadTest, copyRenderPassDrawQuad)
@ -186,26 +280,43 @@ TEST(DrawQuadTest, copyRenderPassDrawQuad)
float maskTexCoordOffsetY = -21;
RenderPass::Id copiedRenderPassId(235, 11);
CREATE_SHARED_STATE();
CREATE_QUAD_8_1(RenderPassDrawQuad, renderPassId, isReplica, maskResourceId, contentsChangedSinceLastFrame, maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY, copiedRenderPassId);
EXPECT_EQ(copiedRenderPassId, copyQuad->renderPassId());
EXPECT_EQ(isReplica, copyQuad->isReplica());
EXPECT_EQ(maskResourceId, copyQuad->maskResourceId());
EXPECT_RECT_EQ(contentsChangedSinceLastFrame, copyQuad->contentsChangedSinceLastFrame());
EXPECT_EQ(maskTexCoordScaleX, copyQuad->maskTexCoordScaleX());
EXPECT_EQ(maskTexCoordScaleY, copyQuad->maskTexCoordScaleY());
EXPECT_EQ(maskTexCoordOffsetX, copyQuad->maskTexCoordOffsetX());
EXPECT_EQ(maskTexCoordOffsetY, copyQuad->maskTexCoordOffsetY());
CREATE_QUAD_8_NEW_1(RenderPassDrawQuad, renderPassId, isReplica, maskResourceId, contentsChangedSinceLastFrame, maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY, copiedRenderPassId);
EXPECT_EQ(DrawQuad::RENDER_PASS, copyQuad->material);
EXPECT_EQ(copiedRenderPassId, copyQuad->render_pass_id);
EXPECT_EQ(isReplica, copyQuad->is_replica);
EXPECT_EQ(maskResourceId, copyQuad->mask_resource_id);
EXPECT_RECT_EQ(contentsChangedSinceLastFrame, copyQuad->contents_changed_since_last_frame);
EXPECT_EQ(maskTexCoordScaleX, copyQuad->mask_tex_coord_scale_x);
EXPECT_EQ(maskTexCoordScaleY, copyQuad->mask_tex_coord_scale_y);
EXPECT_EQ(maskTexCoordOffsetX, copyQuad->mask_tex_coord_offset_x);
EXPECT_EQ(maskTexCoordOffsetY, copyQuad->mask_tex_coord_offset_y);
CREATE_QUAD_8_ALL_1(RenderPassDrawQuad, renderPassId, isReplica, maskResourceId, contentsChangedSinceLastFrame, maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY, copiedRenderPassId);
EXPECT_EQ(DrawQuad::RENDER_PASS, copyQuad->material);
EXPECT_EQ(copiedRenderPassId, copyQuad->render_pass_id);
EXPECT_EQ(isReplica, copyQuad->is_replica);
EXPECT_EQ(maskResourceId, copyQuad->mask_resource_id);
EXPECT_RECT_EQ(contentsChangedSinceLastFrame, copyQuad->contents_changed_since_last_frame);
EXPECT_EQ(maskTexCoordScaleX, copyQuad->mask_tex_coord_scale_x);
EXPECT_EQ(maskTexCoordScaleY, copyQuad->mask_tex_coord_scale_y);
EXPECT_EQ(maskTexCoordOffsetX, copyQuad->mask_tex_coord_offset_x);
EXPECT_EQ(maskTexCoordOffsetY, copyQuad->mask_tex_coord_offset_y);
}
TEST(DrawQuadTest, copySolidColorDrawQuad)
{
SkColor color = 0x49494949;
CREATE_SHARED_STATE();
CREATE_QUAD_1(SolidColorDrawQuad, color);
EXPECT_EQ(color, copyQuad->color());
CREATE_QUAD_1_NEW(SolidColorDrawQuad, color);
EXPECT_EQ(DrawQuad::SOLID_COLOR, copyQuad->material);
EXPECT_EQ(color, copyQuad->color);
CREATE_QUAD_1_ALL(SolidColorDrawQuad, color);
EXPECT_EQ(DrawQuad::SOLID_COLOR, copyQuad->material);
EXPECT_EQ(color, copyQuad->color);
}
TEST(DrawQuadTest, copyStreamVideoDrawQuad)
@ -213,12 +324,18 @@ TEST(DrawQuadTest, copyStreamVideoDrawQuad)
gfx::Rect opaqueRect(3, 7, 10, 12);
unsigned textureId = 64;
WebTransformationMatrix matrix(0.5, 1, 0.25, 0.75, 0, 1);
CREATE_SHARED_STATE();
CREATE_QUAD_3(StreamVideoDrawQuad, opaqueRect, textureId, matrix);
CREATE_QUAD_3_NEW(StreamVideoDrawQuad, opaqueRect, textureId, matrix);
EXPECT_EQ(DrawQuad::STREAM_VIDEO_CONTENT, copyQuad->material);
EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect);
EXPECT_EQ(textureId, copyQuad->textureId());
EXPECT_EQ(matrix, copyQuad->matrix());
EXPECT_EQ(textureId, copyQuad->texture_id);
EXPECT_EQ(matrix, copyQuad->matrix);
CREATE_QUAD_2_ALL(StreamVideoDrawQuad, textureId, matrix);
EXPECT_EQ(DrawQuad::STREAM_VIDEO_CONTENT, copyQuad->material);
EXPECT_EQ(textureId, copyQuad->texture_id);
EXPECT_EQ(matrix, copyQuad->matrix);
}
TEST(DrawQuadTest, copyTextureDrawQuad)
@ -228,14 +345,22 @@ TEST(DrawQuadTest, copyTextureDrawQuad)
bool premultipliedAlpha = true;
gfx::RectF uvRect(0.5, 224, -51, 36);
bool flipped = true;
CREATE_SHARED_STATE();
CREATE_QUAD_5(TextureDrawQuad, opaqueRect, resourceId, premultipliedAlpha, uvRect, flipped);
CREATE_QUAD_5_NEW(TextureDrawQuad, opaqueRect, resourceId, premultipliedAlpha, uvRect, flipped);
EXPECT_EQ(DrawQuad::TEXTURE_CONTENT, copyQuad->material);
EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect);
EXPECT_EQ(resourceId, copyQuad->resourceId());
EXPECT_EQ(premultipliedAlpha, copyQuad->premultipliedAlpha());
EXPECT_FLOAT_RECT_EQ(uvRect, copyQuad->uvRect());
EXPECT_EQ(flipped, copyQuad->flipped());
EXPECT_EQ(resourceId, copyQuad->resource_id);
EXPECT_EQ(premultipliedAlpha, copyQuad->premultiplied_alpha);
EXPECT_FLOAT_RECT_EQ(uvRect, copyQuad->uv_rect);
EXPECT_EQ(flipped, copyQuad->flipped);
CREATE_QUAD_4_ALL(TextureDrawQuad, resourceId, premultipliedAlpha, uvRect, flipped);
EXPECT_EQ(DrawQuad::TEXTURE_CONTENT, copyQuad->material);
EXPECT_EQ(resourceId, copyQuad->resource_id);
EXPECT_EQ(premultipliedAlpha, copyQuad->premultiplied_alpha);
EXPECT_FLOAT_RECT_EQ(uvRect, copyQuad->uv_rect);
EXPECT_EQ(flipped, copyQuad->flipped);
}
TEST(DrawQuadTest, copyTileDrawQuad)
@ -249,18 +374,30 @@ TEST(DrawQuadTest, copyTileDrawQuad)
bool topEdgeAA = true;
bool rightEdgeAA = false;
bool bottomEdgeAA = true;
CREATE_SHARED_STATE();
CREATE_QUAD_9(TileDrawQuad, opaqueRect, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
CREATE_QUAD_9_NEW(TileDrawQuad, opaqueRect, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
EXPECT_EQ(DrawQuad::TILED_CONTENT, copyQuad->material);
EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect);
EXPECT_EQ(resourceId, copyQuad->resourceId());
EXPECT_EQ(texCoordRect, copyQuad->texCoordRect());
EXPECT_EQ(textureSize, copyQuad->textureSize());
EXPECT_EQ(swizzleContents, copyQuad->swizzleContents());
EXPECT_EQ(leftEdgeAA, copyQuad->leftEdgeAA());
EXPECT_EQ(topEdgeAA, copyQuad->topEdgeAA());
EXPECT_EQ(rightEdgeAA, copyQuad->rightEdgeAA());
EXPECT_EQ(bottomEdgeAA, copyQuad->bottomEdgeAA());
EXPECT_EQ(resourceId, copyQuad->resource_id);
EXPECT_EQ(texCoordRect, copyQuad->tex_coord_rect);
EXPECT_EQ(textureSize, copyQuad->texture_size);
EXPECT_EQ(swizzleContents, copyQuad->swizzle_contents);
EXPECT_EQ(leftEdgeAA, copyQuad->left_edge_aa);
EXPECT_EQ(topEdgeAA, copyQuad->top_edge_aa);
EXPECT_EQ(rightEdgeAA, copyQuad->right_edge_aa);
EXPECT_EQ(bottomEdgeAA, copyQuad->bottom_edge_aa);
CREATE_QUAD_8_ALL(TileDrawQuad, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
EXPECT_EQ(DrawQuad::TILED_CONTENT, copyQuad->material);
EXPECT_EQ(resourceId, copyQuad->resource_id);
EXPECT_EQ(texCoordRect, copyQuad->tex_coord_rect);
EXPECT_EQ(textureSize, copyQuad->texture_size);
EXPECT_EQ(swizzleContents, copyQuad->swizzle_contents);
EXPECT_EQ(leftEdgeAA, copyQuad->left_edge_aa);
EXPECT_EQ(topEdgeAA, copyQuad->top_edge_aa);
EXPECT_EQ(rightEdgeAA, copyQuad->right_edge_aa);
EXPECT_EQ(bottomEdgeAA, copyQuad->bottom_edge_aa);
}
TEST(DrawQuadTest, copyYUVVideoDrawQuad)
@ -279,20 +416,34 @@ TEST(DrawQuadTest, copyYUVVideoDrawQuad)
vPlane.resourceId = 4;
vPlane.size = gfx::Size(456, 486);
vPlane.format = 46;
CREATE_SHARED_STATE();
CREATE_QUAD_5(YUVVideoDrawQuad, opaqueRect, texScale, yPlane, uPlane, vPlane);
CREATE_QUAD_5_NEW(YUVVideoDrawQuad, opaqueRect, texScale, yPlane, uPlane, vPlane);
EXPECT_EQ(DrawQuad::YUV_VIDEO_CONTENT, copyQuad->material);
EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect);
EXPECT_EQ(texScale, copyQuad->texScale());
EXPECT_EQ(yPlane.resourceId, copyQuad->yPlane().resourceId);
EXPECT_EQ(yPlane.size, copyQuad->yPlane().size);
EXPECT_EQ(yPlane.format, copyQuad->yPlane().format);
EXPECT_EQ(uPlane.resourceId, copyQuad->uPlane().resourceId);
EXPECT_EQ(uPlane.size, copyQuad->uPlane().size);
EXPECT_EQ(uPlane.format, copyQuad->uPlane().format);
EXPECT_EQ(vPlane.resourceId, copyQuad->vPlane().resourceId);
EXPECT_EQ(vPlane.size, copyQuad->vPlane().size);
EXPECT_EQ(vPlane.format, copyQuad->vPlane().format);
EXPECT_EQ(texScale, copyQuad->tex_scale);
EXPECT_EQ(yPlane.resourceId, copyQuad->y_plane.resourceId);
EXPECT_EQ(yPlane.size, copyQuad->y_plane.size);
EXPECT_EQ(yPlane.format, copyQuad->y_plane.format);
EXPECT_EQ(uPlane.resourceId, copyQuad->u_plane.resourceId);
EXPECT_EQ(uPlane.size, copyQuad->u_plane.size);
EXPECT_EQ(uPlane.format, copyQuad->u_plane.format);
EXPECT_EQ(vPlane.resourceId, copyQuad->v_plane.resourceId);
EXPECT_EQ(vPlane.size, copyQuad->v_plane.size);
EXPECT_EQ(vPlane.format, copyQuad->v_plane.format);
CREATE_QUAD_4_ALL(YUVVideoDrawQuad, texScale, yPlane, uPlane, vPlane);
EXPECT_EQ(DrawQuad::YUV_VIDEO_CONTENT, copyQuad->material);
EXPECT_EQ(texScale, copyQuad->tex_scale);
EXPECT_EQ(yPlane.resourceId, copyQuad->y_plane.resourceId);
EXPECT_EQ(yPlane.size, copyQuad->y_plane.size);
EXPECT_EQ(yPlane.format, copyQuad->y_plane.format);
EXPECT_EQ(uPlane.resourceId, copyQuad->u_plane.resourceId);
EXPECT_EQ(uPlane.size, copyQuad->u_plane.size);
EXPECT_EQ(uPlane.format, copyQuad->u_plane.format);
EXPECT_EQ(vPlane.resourceId, copyQuad->v_plane.resourceId);
EXPECT_EQ(vPlane.size, copyQuad->v_plane.size);
EXPECT_EQ(vPlane.format, copyQuad->v_plane.format);
}
} // namespace

92
cc/gl_renderer.cc

@ -262,31 +262,31 @@ void GLRenderer::drawQuad(DrawingFrame& frame, const DrawQuad* quad)
NOTREACHED();
break;
case DrawQuad::CHECKERBOARD:
drawCheckerboardQuad(frame, CheckerboardDrawQuad::materialCast(quad));
drawCheckerboardQuad(frame, CheckerboardDrawQuad::MaterialCast(quad));
break;
case DrawQuad::DEBUG_BORDER:
drawDebugBorderQuad(frame, DebugBorderDrawQuad::materialCast(quad));
drawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad));
break;
case DrawQuad::IO_SURFACE_CONTENT:
drawIOSurfaceQuad(frame, IOSurfaceDrawQuad::materialCast(quad));
drawIOSurfaceQuad(frame, IOSurfaceDrawQuad::MaterialCast(quad));
break;
case DrawQuad::RENDER_PASS:
drawRenderPassQuad(frame, RenderPassDrawQuad::materialCast(quad));
drawRenderPassQuad(frame, RenderPassDrawQuad::MaterialCast(quad));
break;
case DrawQuad::SOLID_COLOR:
drawSolidColorQuad(frame, SolidColorDrawQuad::materialCast(quad));
drawSolidColorQuad(frame, SolidColorDrawQuad::MaterialCast(quad));
break;
case DrawQuad::STREAM_VIDEO_CONTENT:
drawStreamVideoQuad(frame, StreamVideoDrawQuad::materialCast(quad));
drawStreamVideoQuad(frame, StreamVideoDrawQuad::MaterialCast(quad));
break;
case DrawQuad::TEXTURE_CONTENT:
drawTextureQuad(frame, TextureDrawQuad::materialCast(quad));
drawTextureQuad(frame, TextureDrawQuad::MaterialCast(quad));
break;
case DrawQuad::TILED_CONTENT:
drawTileQuad(frame, TileDrawQuad::materialCast(quad));
drawTileQuad(frame, TileDrawQuad::MaterialCast(quad));
break;
case DrawQuad::YUV_VIDEO_CONTENT:
drawYUVVideoQuad(frame, YUVVideoDrawQuad::materialCast(quad));
drawYUVVideoQuad(frame, YUVVideoDrawQuad::MaterialCast(quad));
break;
}
}
@ -297,7 +297,7 @@ void GLRenderer::drawCheckerboardQuad(const DrawingFrame& frame, const Checkerbo
DCHECK(program && (program->initialized() || isContextLost()));
GLC(context(), context()->useProgram(program->program()));
SkColor color = quad->color();
SkColor color = quad->color;
GLC(context(), context()->uniform4f(program->fragmentShader().colorLocation(), SkColorGetR(color) / 255.0, SkColorGetG(color) / 255.0, SkColorGetB(color) / 255.0, 1));
const int checkerboardWidth = 16;
@ -331,12 +331,12 @@ void GLRenderer::drawDebugBorderQuad(const DrawingFrame& frame, const DebugBorde
GLRenderer::toGLMatrix(&glMatrix[0], frame.projectionMatrix * renderMatrix);
GLC(context(), context()->uniformMatrix4fv(program->vertexShader().matrixLocation(), 1, false, &glMatrix[0]));
SkColor color = quad->color();
SkColor color = quad->color;
float alpha = SkColorGetA(color) / 255.0;
GLC(context(), context()->uniform4f(program->fragmentShader().colorLocation(), (SkColorGetR(color) / 255.0) * alpha, (SkColorGetG(color) / 255.0) * alpha, (SkColorGetB(color) / 255.0) * alpha, alpha));
GLC(context(), context()->lineWidth(quad->width()));
GLC(context(), context()->lineWidth(quad->width));
// The indices for the line are stored in the same array as the triangle indices.
GLC(context(), context()->drawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, 6 * sizeof(unsigned short)));
@ -504,11 +504,11 @@ scoped_ptr<ScopedResource> GLRenderer::drawBackgroundFilters(
void GLRenderer::drawRenderPassQuad(DrawingFrame& frame, const RenderPassDrawQuad* quad)
{
CachedResource* contentsTexture = m_renderPassTextures.get(quad->renderPassId());
CachedResource* contentsTexture = m_renderPassTextures.get(quad->render_pass_id);
if (!contentsTexture || !contentsTexture->id())
return;
const RenderPass* renderPass = frame.renderPassesById->get(quad->renderPassId());
const RenderPass* renderPass = frame.renderPassesById->get(quad->render_pass_id);
DCHECK(renderPass);
if (!renderPass)
return;
@ -566,8 +566,8 @@ void GLRenderer::drawRenderPassQuad(DrawingFrame& frame, const RenderPassDrawQua
scoped_ptr<ResourceProvider::ScopedReadLockGL> maskResourceLock;
unsigned maskTextureId = 0;
if (quad->maskResourceId()) {
maskResourceLock.reset(new ResourceProvider::ScopedReadLockGL(m_resourceProvider, quad->maskResourceId()));
if (quad->mask_resource_id) {
maskResourceLock.reset(new ResourceProvider::ScopedReadLockGL(m_resourceProvider, quad->mask_resource_id));
maskTextureId = maskResourceLock->textureId();
}
@ -627,8 +627,8 @@ void GLRenderer::drawRenderPassQuad(DrawingFrame& frame, const RenderPassDrawQua
DCHECK(shaderMaskTexCoordOffsetLocation != 1);
GLC(context(), context()->activeTexture(GL_TEXTURE1));
GLC(context(), context()->uniform1i(shaderMaskSamplerLocation, 1));
GLC(context(), context()->uniform2f(shaderMaskTexCoordScaleLocation, quad->maskTexCoordScaleX(), quad->maskTexCoordScaleY()));
GLC(context(), context()->uniform2f(shaderMaskTexCoordOffsetLocation, quad->maskTexCoordOffsetX(), quad->maskTexCoordOffsetY()));
GLC(context(), context()->uniform2f(shaderMaskTexCoordScaleLocation, quad->mask_tex_coord_scale_x, quad->mask_tex_coord_scale_y));
GLC(context(), context()->uniform2f(shaderMaskTexCoordOffsetLocation, quad->mask_tex_coord_offset_x, quad->mask_tex_coord_offset_y));
context()->bindTexture(GL_TEXTURE_2D, maskTextureId);
GLC(context(), context()->activeTexture(GL_TEXTURE0));
}
@ -659,7 +659,7 @@ void GLRenderer::drawSolidColorQuad(const DrawingFrame& frame, const SolidColorD
const SolidColorProgram* program = solidColorProgram();
GLC(context(), context()->useProgram(program->program()));
SkColor color = quad->color();
SkColor color = quad->color;
float opacity = quad->opacity();
float alpha = (SkColorGetA(color) / 255.0) * opacity;
@ -697,7 +697,7 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
{
gfx::Rect tileRect = quad->visible_rect;
gfx::RectF texCoordRect = quad->texCoordRect();
gfx::RectF texCoordRect = quad->tex_coord_rect;
float texToGeomScaleX = quad->rect.width() / texCoordRect.width();
float texToGeomScaleY = quad->rect.height() / texCoordRect.height();
@ -737,7 +737,7 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
float vertexTexScaleY = tileRect.height() / clampGeomRect.height();
// Map to normalized texture coordinates.
const gfx::Size& textureSize = quad->textureSize();
const gfx::Size& textureSize = quad->texture_size;
float fragmentTexTranslateX = clampTexRect.x() / textureSize.width();
float fragmentTexTranslateY = clampTexRect.y() / textureSize.height();
float fragmentTexScaleX = clampTexRect.width() / textureSize.width();
@ -756,19 +756,19 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
TileProgramUniforms uniforms;
// For now, we simply skip anti-aliasing with the quad is clipped. This only happens
// on perspective transformed layers that go partially behind the camera.
if (quad->isAntialiased() && !clipped) {
if (quad->swizzleContents())
if (quad->IsAntialiased() && !clipped) {
if (quad->swizzle_contents)
tileUniformLocation(tileProgramSwizzleAA(), uniforms);
else
tileUniformLocation(tileProgramAA(), uniforms);
} else {
if (quad->ShouldDrawWithBlending()) {
if (quad->swizzleContents())
if (quad->swizzle_contents)
tileUniformLocation(tileProgramSwizzle(), uniforms);
else
tileUniformLocation(tileProgram(), uniforms);
} else {
if (quad->swizzleContents())
if (quad->swizzle_contents)
tileUniformLocation(tileProgramSwizzleOpaque(), uniforms);
else
tileUniformLocation(tileProgramOpaque(), uniforms);
@ -777,10 +777,10 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
GLC(context(), context()->useProgram(uniforms.program));
GLC(context(), context()->uniform1i(uniforms.samplerLocation, 0));
ResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId());
ResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resource_id);
GLC(context(), context()->bindTexture(GL_TEXTURE_2D, quadResourceLock.textureId()));
bool useAA = !clipped && quad->isAntialiased();
bool useAA = !clipped && quad->IsAntialiased();
if (useAA) {
LayerQuad deviceLayerBounds = LayerQuad(gfx::QuadF(deviceLayerQuad.BoundingBox()));
deviceLayerBounds.inflateAntiAliasingDistance();
@ -817,13 +817,13 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
LayerQuad::Edge rightEdge(topRight, bottomRight);
// Only apply anti-aliasing to edges not clipped by culling or scissoring.
if (quad->topEdgeAA() && tileRect.y() == quad->rect.y())
if (quad->top_edge_aa && tileRect.y() == quad->rect.y())
topEdge = deviceLayerEdges.top();
if (quad->leftEdgeAA() && tileRect.x() == quad->rect.x())
if (quad->left_edge_aa && tileRect.x() == quad->rect.x())
leftEdge = deviceLayerEdges.left();
if (quad->rightEdgeAA() && tileRect.right() == quad->rect.right())
if (quad->right_edge_aa && tileRect.right() == quad->rect.right())
rightEdge = deviceLayerEdges.right();
if (quad->bottomEdgeAA() && tileRect.bottom() == quad->rect.bottom())
if (quad->bottom_edge_aa && tileRect.bottom() == quad->rect.bottom())
bottomEdge = deviceLayerEdges.bottom();
float sign = gfx::QuadF(tileRect).IsCounterClockwise() ? -1 : 1;
@ -878,9 +878,9 @@ void GLRenderer::drawYUVVideoQuad(const DrawingFrame& frame, const YUVVideoDrawQ
const VideoYUVProgram* program = videoYUVProgram();
DCHECK(program && (program->initialized() || isContextLost()));
const VideoLayerImpl::FramePlane& yPlane = quad->yPlane();
const VideoLayerImpl::FramePlane& uPlane = quad->uPlane();
const VideoLayerImpl::FramePlane& vPlane = quad->vPlane();
const VideoLayerImpl::FramePlane& yPlane = quad->y_plane;
const VideoLayerImpl::FramePlane& uPlane = quad->u_plane;
const VideoLayerImpl::FramePlane& vPlane = quad->v_plane;
ResourceProvider::ScopedReadLockGL yPlaneLock(m_resourceProvider, yPlane.resourceId);
ResourceProvider::ScopedReadLockGL uPlaneLock(m_resourceProvider, uPlane.resourceId);
@ -894,7 +894,7 @@ void GLRenderer::drawYUVVideoQuad(const DrawingFrame& frame, const YUVVideoDrawQ
GLC(context(), context()->useProgram(program->program()));
GLC(context(), context()->uniform2f(program->vertexShader().texScaleLocation(), quad->texScale().width(), quad->texScale().height()));
GLC(context(), context()->uniform2f(program->vertexShader().texScaleLocation(), quad->tex_scale.width(), quad->tex_scale.height()));
GLC(context(), context()->uniform1i(program->fragmentShader().yTextureLocation(), 1));
GLC(context(), context()->uniform1i(program->fragmentShader().uTextureLocation(), 2));
GLC(context(), context()->uniform1i(program->fragmentShader().vTextureLocation(), 3));
@ -937,10 +937,10 @@ void GLRenderer::drawStreamVideoQuad(const DrawingFrame& frame, const StreamVide
const VideoStreamTextureProgram* program = videoStreamTextureProgram();
GLC(context(), context()->useProgram(program->program()));
toGLMatrix(&glMatrix[0], quad->matrix());
toGLMatrix(&glMatrix[0], quad->matrix);
GLC(context(), context()->uniformMatrix4fv(program->vertexShader().texMatrixLocation(), 1, false, glMatrix));
GLC(context(), context()->bindTexture(GL_TEXTURE_EXTERNAL_OES, quad->textureId()));
GLC(context(), context()->bindTexture(GL_TEXTURE_EXTERNAL_OES, quad->texture_id));
GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0));
@ -977,19 +977,19 @@ struct TexTransformTextureProgramBinding : TextureProgramBinding {
void GLRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureDrawQuad* quad)
{
TexTransformTextureProgramBinding binding;
if (quad->flipped())
if (quad->flipped)
binding.set(textureProgramFlip(), context());
else
binding.set(textureProgram(), context());
GLC(context(), context()->useProgram(binding.programId));
GLC(context(), context()->uniform1i(binding.samplerLocation, 0));
const gfx::RectF& uvRect = quad->uvRect();
const gfx::RectF& uvRect = quad->uv_rect;
GLC(context(), context()->uniform4f(binding.texTransformLocation, uvRect.x(), uvRect.y(), uvRect.width(), uvRect.height()));
ResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId());
ResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resource_id);
GLC(context(), context()->bindTexture(GL_TEXTURE_2D, quadResourceLock.textureId()));
if (!quad->premultipliedAlpha()) {
if (!quad->premultiplied_alpha) {
// As it turns out, the premultiplied alpha blending function (ONE, ONE_MINUS_SRC_ALPHA)
// will never cause the alpha channel to be set to anything less than 1.0 if it is
// initialized to that value! Therefore, premultipliedAlpha being false is the first
@ -1004,7 +1004,7 @@ void GLRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureDrawQua
setShaderOpacity(quad->opacity(), binding.alphaLocation);
drawQuadGeometry(frame, quad->quadTransform(), quad->rect, binding.matrixLocation);
if (!quad->premultipliedAlpha())
if (!quad->premultiplied_alpha)
GLC(m_context, m_context->blendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
}
@ -1015,12 +1015,12 @@ void GLRenderer::drawIOSurfaceQuad(const DrawingFrame& frame, const IOSurfaceDra
GLC(context(), context()->useProgram(binding.programId));
GLC(context(), context()->uniform1i(binding.samplerLocation, 0));
if (quad->orientation() == IOSurfaceDrawQuad::Flipped)
GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, quad->ioSurfaceSize().height(), quad->ioSurfaceSize().width(), quad->ioSurfaceSize().height() * -1.0));
if (quad->orientation == IOSurfaceDrawQuad::FLIPPED)
GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, quad->io_surface_size.height(), quad->io_surface_size.width(), quad->io_surface_size.height() * -1.0));
else
GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, 0, quad->ioSurfaceSize().width(), quad->ioSurfaceSize().height()));
GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, 0, quad->io_surface_size.width(), quad->io_surface_size.height()));
GLC(context(), context()->bindTexture(GL_TEXTURE_RECTANGLE_ARB, quad->ioSurfaceTextureId()));
GLC(context(), context()->bindTexture(GL_TEXTURE_RECTANGLE_ARB, quad->io_surface_texture_id));
setShaderOpacity(quad->opacity(), binding.alphaLocation);
drawQuadGeometry(frame, quad->quadTransform(), quad->rect, binding.matrixLocation);

4
cc/heads_up_display_layer_impl.cc

@ -95,7 +95,9 @@ void HeadsUpDisplayLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& a
bool premultipliedAlpha = true;
gfx::RectF uvRect(0, 0, 1, 1);
bool flipped = false;
quadSink.append(TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_hudTexture->id(), premultipliedAlpha, uvRect, flipped).PassAs<DrawQuad>(), appendQuadsData);
scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_hudTexture->id(), premultipliedAlpha, uvRect, flipped);
quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
}
void HeadsUpDisplayLayerImpl::updateHudTexture(ResourceProvider* resourceProvider)

54
cc/io_surface_draw_quad.cc

@ -8,25 +8,49 @@
namespace cc {
scoped_ptr<IOSurfaceDrawQuad> IOSurfaceDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, const gfx::Size& ioSurfaceSize, unsigned ioSurfaceTextureId, Orientation orientation)
{
return make_scoped_ptr(new IOSurfaceDrawQuad(sharedQuadState, quadRect, opaqueRect, ioSurfaceSize, ioSurfaceTextureId, orientation));
IOSurfaceDrawQuad::IOSurfaceDrawQuad()
: io_surface_texture_id(0),
orientation(FLIPPED) {
}
IOSurfaceDrawQuad::IOSurfaceDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, const gfx::Size& ioSurfaceSize, unsigned ioSurfaceTextureId, Orientation orientation)
: m_ioSurfaceSize(ioSurfaceSize)
, m_ioSurfaceTextureId(ioSurfaceTextureId)
, m_orientation(orientation)
{
gfx::Rect visibleRect = quadRect;
bool needsBlending = false;
DrawQuad::SetAll(sharedQuadState, DrawQuad::IO_SURFACE_CONTENT, quadRect, opaqueRect, visibleRect, needsBlending);
scoped_ptr<IOSurfaceDrawQuad> IOSurfaceDrawQuad::Create() {
return make_scoped_ptr(new IOSurfaceDrawQuad);
}
const IOSurfaceDrawQuad* IOSurfaceDrawQuad::materialCast(const DrawQuad* quad)
{
DCHECK(quad->material == DrawQuad::IO_SURFACE_CONTENT);
return static_cast<const IOSurfaceDrawQuad*>(quad);
void IOSurfaceDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Size io_surface_size,
unsigned io_surface_texture_id,
Orientation orientation) {
gfx::Rect visible_rect = rect;
bool needs_blending = false;
DrawQuad::SetAll(shared_quad_state, DrawQuad::IO_SURFACE_CONTENT, rect,
opaque_rect, visible_rect, needs_blending);
this->io_surface_size = io_surface_size;
this->io_surface_texture_id = io_surface_texture_id;
this->orientation = orientation;
}
void IOSurfaceDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Rect visible_rect,
bool needs_blending,
gfx::Size io_surface_size,
unsigned io_surface_texture_id,
Orientation orientation) {
DrawQuad::SetAll(shared_quad_state, DrawQuad::IO_SURFACE_CONTENT, rect,
opaque_rect, visible_rect, needs_blending);
this->io_surface_size = io_surface_size;
this->io_surface_texture_id = io_surface_texture_id;
this->orientation = orientation;
}
const IOSurfaceDrawQuad* IOSurfaceDrawQuad::MaterialCast(
const DrawQuad* quad) {
DCHECK(quad->material == DrawQuad::IO_SURFACE_CONTENT);
return static_cast<const IOSurfaceDrawQuad*>(quad);
}
} // namespace cc

42
cc/io_surface_draw_quad.h

@ -13,25 +13,37 @@
namespace cc {
class CC_EXPORT IOSurfaceDrawQuad : public DrawQuad {
public:
enum Orientation {
Flipped,
Unflipped
};
public:
enum Orientation {
FLIPPED,
UNFLIPPED
};
static scoped_ptr<IOSurfaceDrawQuad> create(const SharedQuadState*, const gfx::Rect&, const gfx::Rect& opaqueRect, const gfx::Size& ioSurfaceSize, unsigned ioSurfaceTextureId, Orientation);
static scoped_ptr<IOSurfaceDrawQuad> Create();
gfx::Size ioSurfaceSize() const { return m_ioSurfaceSize; }
unsigned ioSurfaceTextureId() const { return m_ioSurfaceTextureId; }
Orientation orientation() const { return m_orientation; }
void SetNew(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Size io_surface_size,
unsigned io_surface_texture_id,
Orientation orientation);
static const IOSurfaceDrawQuad* materialCast(const DrawQuad*);
private:
IOSurfaceDrawQuad(const SharedQuadState*, const gfx::Rect&, const gfx::Rect& opaqueRect, const gfx::Size& ioSurfaceSize, unsigned ioSurfaceTextureId, Orientation);
void SetAll(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Rect visible_rect,
bool needs_blending,
gfx::Size io_surface_size,
unsigned io_surface_texture_id,
Orientation orientation);
gfx::Size m_ioSurfaceSize;
unsigned m_ioSurfaceTextureId;
Orientation m_orientation;
gfx::Size io_surface_size;
unsigned io_surface_texture_id;
Orientation orientation;
static const IOSurfaceDrawQuad* MaterialCast(const DrawQuad*);
private:
IOSurfaceDrawQuad();
};
}

4
cc/io_surface_layer_impl.cc

@ -79,7 +79,9 @@ void IOSurfaceLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& append
gfx::Rect quadRect(gfx::Point(), contentBounds());
gfx::Rect opaqueRect(contentsOpaque() ? quadRect : gfx::Rect());
quadSink.append(IOSurfaceDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_ioSurfaceSize, m_ioSurfaceTextureId, IOSurfaceDrawQuad::Flipped).PassAs<DrawQuad>(), appendQuadsData);
scoped_ptr<IOSurfaceDrawQuad> quad = IOSurfaceDrawQuad::Create();
quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_ioSurfaceSize, m_ioSurfaceTextureId, IOSurfaceDrawQuad::FLIPPED);
quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
}
void IOSurfaceLayerImpl::dumpLayerProperties(std::string* str, int indent) const

4
cc/layer_impl.cc

@ -179,7 +179,9 @@ void LayerImpl::appendDebugBorderQuad(QuadSink& quadList, const SharedQuadState*
getDebugBorderProperties(&color, &width);
gfx::Rect contentRect(gfx::Point(), contentBounds());
quadList.append(DebugBorderDrawQuad::create(sharedQuadState, contentRect, color, width).PassAs<DrawQuad>(), appendQuadsData);
scoped_ptr<DebugBorderDrawQuad> debugBorderQuad = DebugBorderDrawQuad::Create();
debugBorderQuad->SetNew(sharedQuadState, contentRect, color, width);
quadList.append(debugBorderQuad.PassAs<DrawQuad>(), appendQuadsData);
}
bool LayerImpl::hasContributingDelegatedRenderPasses() const

10
cc/layer_tree_host_impl.cc

@ -564,19 +564,19 @@ static void removeRenderPassesRecursive(RenderPass::Id removeRenderPassId, Layer
if (currentQuad->material != DrawQuad::RENDER_PASS)
continue;
RenderPass::Id nextRemoveRenderPassId = RenderPassDrawQuad::materialCast(currentQuad)->renderPassId();
RenderPass::Id nextRemoveRenderPassId = RenderPassDrawQuad::MaterialCast(currentQuad)->render_pass_id;
removeRenderPassesRecursive(nextRemoveRenderPassId, frame);
}
}
bool LayerTreeHostImpl::CullRenderPassesWithCachedTextures::shouldRemoveRenderPass(const RenderPassDrawQuad& quad, const FrameData&) const
{
return quad.contentsChangedSinceLastFrame().IsEmpty() && m_renderer.haveCachedResourcesForRenderPassId(quad.renderPassId());
return quad.contents_changed_since_last_frame.IsEmpty() && m_renderer.haveCachedResourcesForRenderPassId(quad.render_pass_id);
}
bool LayerTreeHostImpl::CullRenderPassesWithNoQuads::shouldRemoveRenderPass(const RenderPassDrawQuad& quad, const FrameData& frame) const
{
const RenderPass* renderPass = findRenderPassById(quad.renderPassId(), frame);
const RenderPass* renderPass = findRenderPassById(quad.render_pass_id, frame);
const RenderPassList& renderPasses = frame.renderPasses;
RenderPassList::const_iterator foundPass = std::find(renderPasses.begin(), renderPasses.end(), renderPass);
@ -592,7 +592,7 @@ bool LayerTreeHostImpl::CullRenderPassesWithNoQuads::shouldRemoveRenderPass(cons
if (currentQuad->material != DrawQuad::RENDER_PASS)
return false;
const RenderPass* contributingPass = findRenderPassById(RenderPassDrawQuad::materialCast(currentQuad)->renderPassId(), frame);
const RenderPass* contributingPass = findRenderPassById(RenderPassDrawQuad::MaterialCast(currentQuad)->render_pass_id, frame);
RenderPassList::const_iterator foundContributingPass = std::find(renderPasses.begin(), renderPasses.end(), contributingPass);
if (foundContributingPass != renderPasses.end())
return false;
@ -629,7 +629,7 @@ void LayerTreeHostImpl::removeRenderPasses(RenderPassCuller culler, FrameData& f
// change. So, capture the iterator position from the end of the
// list, and restore it after the change.
int positionFromEnd = frame.renderPasses.size() - it;
removeRenderPassesRecursive(renderPassQuad->renderPassId(), frame);
removeRenderPassesRecursive(renderPassQuad->render_pass_id, frame);
it = frame.renderPasses.size() - positionFromEnd;
DCHECK(it >= 0);
}

71
cc/layer_tree_host_impl_unittest.cc

@ -1602,7 +1602,8 @@ public:
opaqueRect = m_opaqueContentRect;
SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
scoped_ptr<TileDrawQuad> testBlendingDrawQuad = TileDrawQuad::create(sharedQuadState, m_quadRect, opaqueRect, m_resourceId, gfx::RectF(0, 0, 1, 1), gfx::Size(1, 1), false, false, false, false, false);
scoped_ptr<TileDrawQuad> testBlendingDrawQuad = TileDrawQuad::Create();
testBlendingDrawQuad->SetNew(sharedQuadState, m_quadRect, opaqueRect, m_resourceId, gfx::RectF(0, 0, 1, 1), gfx::Size(1, 1), false, false, false, false, false);
testBlendingDrawQuad->visible_rect = m_quadVisibleRect;
EXPECT_EQ(m_blend, testBlendingDrawQuad->ShouldDrawWithBlending());
EXPECT_EQ(m_hasRenderSurface, !!renderSurface());
@ -2105,7 +2106,8 @@ public:
SkColor gray = SkColorSetRGB(100, 100, 100);
gfx::Rect quadRect(gfx::Point(0, 0), contentBounds());
scoped_ptr<SolidColorDrawQuad> myQuad = SolidColorDrawQuad::create(sharedQuadState, quadRect, gray);
scoped_ptr<SolidColorDrawQuad> myQuad = SolidColorDrawQuad::Create();
myQuad->SetNew(sharedQuadState, quadRect, gray);
quadSink.append(myQuad.PassAs<DrawQuad>(), appendQuadsData);
}
@ -2714,7 +2716,8 @@ static inline scoped_ptr<RenderPass> createRenderPassWithResource(ResourceProvid
scoped_ptr<TestRenderPass> pass = TestRenderPass::create(RenderPass::Id(1, 1), gfx::Rect(0, 0, 1, 1), WebTransformationMatrix());
scoped_ptr<SharedQuadState> sharedState = SharedQuadState::create(WebTransformationMatrix(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), 1);
scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::create(sharedState.get(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), resourceId, false, gfx::RectF(0, 0, 1, 1), false);
scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
quad->SetNew(sharedState.get(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), resourceId, false, gfx::RectF(0, 0, 1, 1), false);
pass->appendSharedQuadState(sharedState.Pass());
pass->appendQuad(quad.PassAs<DrawQuad>());
@ -3158,8 +3161,8 @@ TEST_P(LayerTreeHostImplTest, textureCachingWithClipping)
EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), frame.renderPasses[0]->outputRect());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]);
EXPECT_FALSE(quad->contentsChangedSinceLastFrame().IsEmpty());
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
EXPECT_FALSE(quad->contents_changed_since_last_frame.IsEmpty());
myHostImpl->drawLayers(frame);
myHostImpl->didDrawAllLayers(frame);
@ -3816,8 +3819,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
EXPECT_EQ(1U, frame.renderPasses[1]->quadList().size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_FALSE(targetPass->damageRect().IsEmpty());
myHostImpl->drawLayers(frame);
@ -3834,8 +3837,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[0]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_TRUE(targetPass->damageRect().IsEmpty());
myHostImpl->drawLayers(frame);
@ -3853,8 +3856,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[0]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_TRUE(targetPass->damageRect().IsEmpty());
myHostImpl->drawLayers(frame);
@ -3874,8 +3877,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quadList()[0]->material);
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_FALSE(targetPass->damageRect().IsEmpty());
myHostImpl->drawLayers(frame);
@ -3901,8 +3904,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
EXPECT_EQ(1U, frame.renderPasses[1]->quadList().size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_TRUE(targetPass->damageRect().IsEmpty());
// Was our surface evicted?
@ -3922,8 +3925,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[0]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_TRUE(targetPass->damageRect().IsEmpty());
myHostImpl->drawLayers(frame);
@ -3943,8 +3946,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[0]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_TRUE(targetPass->damageRect().IsEmpty());
myHostImpl->drawLayers(frame);
@ -3975,8 +3978,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
EXPECT_EQ(1U, frame.renderPasses[1]->quadList().size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_FALSE(targetPass->damageRect().IsEmpty());
EXPECT_FALSE(frame.renderPasses[0]->damageRect().IsEmpty());
@ -4017,8 +4020,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[0]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_TRUE(targetPass->damageRect().IsEmpty());
myHostImpl->drawLayers(frame);
@ -4038,8 +4041,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quadList()[0]->material);
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_FALSE(targetPass->damageRect().IsEmpty());
myHostImpl->drawLayers(frame);
@ -4065,8 +4068,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
EXPECT_EQ(1U, frame.renderPasses[1]->quadList().size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_TRUE(targetPass->damageRect().IsEmpty());
// Was our surface evicted?
@ -4104,8 +4107,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material);
const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[0]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]);
RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
EXPECT_TRUE(targetPass->damageRect().IsEmpty());
myHostImpl->drawLayers(frame);
@ -4212,7 +4215,8 @@ static void configureRenderPassTestData(const char* testScript, RenderPassRemova
while (*currentChar && *currentChar != '\n') {
if (*currentChar == 's') {
// Solid color draw quad
scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::create(testData.sharedQuadState.get(), gfx::Rect(0, 0, 10, 10), SK_ColorWHITE);
scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
quad->SetNew(testData.sharedQuadState.get(), gfx::Rect(0, 0, 10, 10), SK_ColorWHITE);
renderPass->appendQuad(quad.PassAs<DrawQuad>());
currentChar++;
@ -4254,7 +4258,8 @@ static void configureRenderPassTestData(const char* testScript, RenderPassRemova
gfx::Rect quadRect = gfx::Rect(0, 0, 1, 1);
gfx::Rect contentsChangedRect = contentsChanged ? quadRect : gfx::Rect();
scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::create(testData.sharedQuadState.get(), quadRect, newRenderPassId, isReplica, 1, contentsChangedRect, 1, 1, 0, 0);
scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
quad->SetNew(testData.sharedQuadState.get(), quadRect, newRenderPassId, isReplica, 1, contentsChangedRect, 1, 1, 0, 0);
renderPass->appendQuad(quad.PassAs<DrawQuad>());
}
}
@ -4284,9 +4289,9 @@ void dumpRenderPassTestData(const RenderPassRemovalTestData& testData, char* buf
pos++;
break;
case DrawQuad::RENDER_PASS:
*pos = RenderPassDrawQuad::materialCast(currentQuad)->renderPassId().layerId;
*pos = RenderPassDrawQuad::MaterialCast(currentQuad)->render_pass_id.layerId;
pos++;
*pos = RenderPassDrawQuad::materialCast(currentQuad)->renderPassId().index;
*pos = RenderPassDrawQuad::MaterialCast(currentQuad)->render_pass_id.index;
pos++;
break;
default:

40
cc/nine_patch_layer_impl.cc

@ -86,15 +86,39 @@ void NinePatchLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& append
// Nothing is opaque here.
// TODO(danakj): Should we look at the SkBitmaps to determine opaqueness?
gfx::Rect opaqueRect;
scoped_ptr<TextureDrawQuad> quad;
quadSink.append(TextureDrawQuad::create(sharedQuadState, topLeft, opaqueRect, m_resourceId, premultipliedAlpha, uvTopLeft, flipped).PassAs<DrawQuad>(), appendQuadsData);
quadSink.append(TextureDrawQuad::create(sharedQuadState, topRight, opaqueRect, m_resourceId, premultipliedAlpha, uvTopRight, flipped).PassAs<DrawQuad>(), appendQuadsData);
quadSink.append(TextureDrawQuad::create(sharedQuadState, bottomLeft, opaqueRect, m_resourceId, premultipliedAlpha, uvBottomLeft, flipped).PassAs<DrawQuad>(), appendQuadsData);
quadSink.append(TextureDrawQuad::create(sharedQuadState, bottomRight, opaqueRect, m_resourceId, premultipliedAlpha, uvBottomRight, flipped).PassAs<DrawQuad>(), appendQuadsData);
quadSink.append(TextureDrawQuad::create(sharedQuadState, top, opaqueRect, m_resourceId, premultipliedAlpha, uvTop, flipped).PassAs<DrawQuad>(), appendQuadsData);
quadSink.append(TextureDrawQuad::create(sharedQuadState, left, opaqueRect, m_resourceId, premultipliedAlpha, uvLeft, flipped).PassAs<DrawQuad>(), appendQuadsData);
quadSink.append(TextureDrawQuad::create(sharedQuadState, right, opaqueRect, m_resourceId, premultipliedAlpha, uvRight, flipped).PassAs<DrawQuad>(), appendQuadsData);
quadSink.append(TextureDrawQuad::create(sharedQuadState, bottom, opaqueRect, m_resourceId, premultipliedAlpha, uvBottom, flipped).PassAs<DrawQuad>(), appendQuadsData);
quad = TextureDrawQuad::Create();
quad->SetNew(sharedQuadState, topLeft, opaqueRect, m_resourceId, premultipliedAlpha, uvTopLeft, flipped);
quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
quad = TextureDrawQuad::Create();
quad->SetNew(sharedQuadState, topRight, opaqueRect, m_resourceId, premultipliedAlpha, uvTopRight, flipped);
quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
quad = TextureDrawQuad::Create();
quad->SetNew(sharedQuadState, bottomLeft, opaqueRect, m_resourceId, premultipliedAlpha, uvBottomLeft, flipped);
quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
quad = TextureDrawQuad::Create();
quad->SetNew(sharedQuadState, bottomRight, opaqueRect, m_resourceId, premultipliedAlpha, uvBottomRight, flipped);
quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
quad = TextureDrawQuad::Create();
quad->SetNew(sharedQuadState, top, opaqueRect, m_resourceId, premultipliedAlpha, uvTop, flipped);
quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
quad = TextureDrawQuad::Create();
quad->SetNew(sharedQuadState, left, opaqueRect, m_resourceId, premultipliedAlpha, uvLeft, flipped);
quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
quad = TextureDrawQuad::Create();
quad->SetNew(sharedQuadState, right, opaqueRect, m_resourceId, premultipliedAlpha, uvRight, flipped);
quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
quad = TextureDrawQuad::Create();
quad->SetNew(sharedQuadState, bottom, opaqueRect, m_resourceId, premultipliedAlpha, uvBottom, flipped);
quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
}
void NinePatchLayerImpl::didDraw(ResourceProvider* resourceProvider)

4
cc/nine_patch_layer_impl_unittest.cc

@ -75,8 +75,8 @@ TEST(NinePatchLayerImplTest, verifyDrawQuads)
Region texRemaining(bitmapRect);
for (size_t i = 0; i < quads.size(); ++i) {
DrawQuad* quad = quads[i];
const TextureDrawQuad* texQuad = TextureDrawQuad::materialCast(quad);
gfx::RectF texRect = texQuad->uvRect();
const TextureDrawQuad* texQuad = TextureDrawQuad::MaterialCast(quad);
gfx::RectF texRect = texQuad->uv_rect;
texRect.Scale(bitmapSize.width(), bitmapSize.height());
texRemaining.Subtract(Region(ToRoundedIntRect(texRect)));
}

25
cc/picture_layer_impl.cc

@ -61,18 +61,19 @@ void PictureLayerImpl::appendQuads(QuadSink& quadSink,
bool outside_right_edge = geometry_rect.right() == content_rect.right();
bool outside_bottom_edge = geometry_rect.bottom() == content_rect.bottom();
quadSink.append(TileDrawQuad::create(
sharedQuadState,
geometry_rect,
opaque_rect,
resource,
texture_rect,
iter.texture_size(),
iter->contents_swizzled(),
outside_left_edge && useAA,
outside_top_edge && useAA,
outside_right_edge && useAA,
outside_bottom_edge && useAA).PassAs<DrawQuad>(), appendQuadsData);
scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
quad->SetNew(sharedQuadState,
geometry_rect,
opaque_rect,
resource,
texture_rect,
iter.texture_size(),
iter->contents_swizzled(),
outside_left_edge && useAA,
outside_top_edge && useAA,
outside_right_edge && useAA,
outside_bottom_edge && useAA);
quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
}
}

4
cc/quad_culler.cc

@ -53,7 +53,9 @@ static inline bool appendQuadInternal(scoped_ptr<DrawQuad> drawQuad, const gfx::
if (createDebugBorderQuads && !drawQuad->IsDebugQuad() && drawQuad->visible_rect != drawQuad->rect) {
SkColor color = DebugColors::CulledTileBorderColor();
float width = DebugColors::CulledTileBorderWidth(layer ? layer->layerTreeHostImpl() : NULL);
quadList.append(DebugBorderDrawQuad::create(drawQuad->shared_quad_state, drawQuad->visible_rect, color, width).PassAs<DrawQuad>());
scoped_ptr<DebugBorderDrawQuad> debugBorderQuad = DebugBorderDrawQuad::Create();
debugBorderQuad->SetNew(drawQuad->shared_quad_state, drawQuad->visible_rect, color, width);
quadList.append(debugBorderQuad.PassAs<DrawQuad>());
}
// Pass the quad after we're done using it.

4
cc/render_pass.cc

@ -99,7 +99,9 @@ void RenderPass::appendQuadsToFillScreen(LayerImpl* rootLayer, SkColor screenBac
// The root layer transform is composed of translations and scales only, no perspective, so mapping is sufficient.
gfx::Rect layerRect = MathUtil::mapClippedRect(transformToLayerSpace, fillRects.rect());
// Skip the quad culler and just append the quads directly to avoid occlusion checks.
m_quadList.append(SolidColorDrawQuad::create(sharedQuadState, layerRect, screenBackgroundColor).PassAs<DrawQuad>());
scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
quad->SetNew(sharedQuadState, layerRect, screenBackgroundColor);
m_quadList.append(quad.PassAs<DrawQuad>());
}
}

107
cc/render_pass_draw_quad.cc

@ -6,42 +6,89 @@
namespace cc {
scoped_ptr<RenderPassDrawQuad> RenderPassDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, RenderPass::Id renderPassId, bool isReplica, const ResourceProvider::ResourceId maskResourceId, const gfx::Rect& contentsChangedSinceLastFrame, float maskTexCoordScaleX, float maskTexCoordScaleY, float maskTexCoordOffsetX, float maskTexCoordOffsetY)
{
return make_scoped_ptr(new RenderPassDrawQuad(sharedQuadState, quadRect, renderPassId, isReplica, maskResourceId, contentsChangedSinceLastFrame, maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY));
RenderPassDrawQuad::RenderPassDrawQuad()
: render_pass_id(RenderPass::Id(-1, -1)),
is_replica(false),
mask_resource_id(-1),
mask_tex_coord_scale_x(0),
mask_tex_coord_scale_y(0),
mask_tex_coord_offset_x(0),
mask_tex_coord_offset_y(0) {
}
RenderPassDrawQuad::RenderPassDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, RenderPass::Id renderPassId, bool isReplica, ResourceProvider::ResourceId maskResourceId, const gfx::Rect& contentsChangedSinceLastFrame, float maskTexCoordScaleX, float maskTexCoordScaleY, float maskTexCoordOffsetX, float maskTexCoordOffsetY)
: m_renderPassId(renderPassId)
, m_isReplica(isReplica)
, m_maskResourceId(maskResourceId)
, m_contentsChangedSinceLastFrame(contentsChangedSinceLastFrame)
, m_maskTexCoordScaleX(maskTexCoordScaleX)
, m_maskTexCoordScaleY(maskTexCoordScaleY)
, m_maskTexCoordOffsetX(maskTexCoordOffsetX)
, m_maskTexCoordOffsetY(maskTexCoordOffsetY)
{
DCHECK(m_renderPassId.layerId > 0);
DCHECK(m_renderPassId.index >= 0);
gfx::Rect opaqueRect;
gfx::Rect visibleRect = quadRect;
bool needsBlending = false;
DrawQuad::SetAll(sharedQuadState, DrawQuad::RENDER_PASS, quadRect, opaqueRect, visibleRect, needsBlending);
scoped_ptr<RenderPassDrawQuad> RenderPassDrawQuad::Create() {
return make_scoped_ptr(new RenderPassDrawQuad);
}
const RenderPassDrawQuad* RenderPassDrawQuad::materialCast(const DrawQuad* quad)
{
DCHECK(quad->material == DrawQuad::RENDER_PASS);
return static_cast<const RenderPassDrawQuad*>(quad);
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();
}
scoped_ptr<RenderPassDrawQuad> RenderPassDrawQuad::copy(const SharedQuadState* copiedSharedQuadState, RenderPass::Id copiedRenderPassId) const
{
scoped_ptr<RenderPassDrawQuad> copyQuad(new RenderPassDrawQuad(*materialCast(this)));
copyQuad->shared_quad_state = copiedSharedQuadState;
copyQuad->m_renderPassId = copiedRenderPassId;
return copyQuad.Pass();
void RenderPassDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
RenderPass::Id render_pass_id,
bool is_replica,
ResourceProvider::ResourceId mask_resource_id,
gfx::Rect contents_changed_since_last_frame,
float mask_tex_coord_scale_x,
float mask_tex_coord_scale_y,
float mask_tex_coord_offset_x,
float mask_tex_coord_offset_y) {
DCHECK(render_pass_id.layerId > 0);
DCHECK(render_pass_id.index >= 0);
gfx::Rect opaque_rect;
gfx::Rect visible_rect = rect;
bool needs_blending = false;
DrawQuad::SetAll(shared_quad_state, DrawQuad::RENDER_PASS, rect, opaque_rect,
visible_rect, needs_blending);
this->render_pass_id = render_pass_id;
this->is_replica = is_replica;
this->mask_resource_id = mask_resource_id;
this->contents_changed_since_last_frame = contents_changed_since_last_frame;
this->mask_tex_coord_scale_x = mask_tex_coord_scale_x;
this->mask_tex_coord_scale_y = mask_tex_coord_scale_y;
this->mask_tex_coord_offset_x = mask_tex_coord_offset_x;
this->mask_tex_coord_offset_y = mask_tex_coord_offset_y;
}
void RenderPassDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Rect visible_rect,
bool needs_blending,
RenderPass::Id render_pass_id,
bool is_replica,
ResourceProvider::ResourceId mask_resource_id,
gfx::Rect contents_changed_since_last_frame,
float mask_tex_coord_scale_x,
float mask_tex_coord_scale_y,
float mask_tex_coord_offset_x,
float mask_tex_coord_offset_y) {
DCHECK(render_pass_id.layerId > 0);
DCHECK(render_pass_id.index >= 0);
DrawQuad::SetAll(shared_quad_state, DrawQuad::RENDER_PASS, rect, opaque_rect,
visible_rect, needs_blending);
this->render_pass_id = render_pass_id;
this->is_replica = is_replica;
this->mask_resource_id = mask_resource_id;
this->contents_changed_since_last_frame = contents_changed_since_last_frame;
this->mask_tex_coord_scale_x = mask_tex_coord_scale_x;
this->mask_tex_coord_scale_y = mask_tex_coord_scale_y;
this->mask_tex_coord_offset_x = mask_tex_coord_offset_x;
this->mask_tex_coord_offset_y = mask_tex_coord_offset_y;
}
const RenderPassDrawQuad* RenderPassDrawQuad::MaterialCast(
const DrawQuad* quad) {
DCHECK(quad->material == DrawQuad::RENDER_PASS);
return static_cast<const RenderPassDrawQuad*>(quad);
}
} // namespace cc

62
cc/render_pass_draw_quad.h

@ -15,33 +15,51 @@
namespace cc {
class CC_EXPORT RenderPassDrawQuad : public DrawQuad {
public:
static scoped_ptr<RenderPassDrawQuad> create(const SharedQuadState*, const gfx::Rect&, RenderPass::Id renderPassId, bool isReplica, ResourceProvider::ResourceId maskResourceId, const gfx::Rect& contentsChangedSinceLastFrame, float maskTexCoordScaleX, float maskTexCoordScaleY, float maskTexCoordOffsetX, float maskTexCoordOffsetY);
public:
static scoped_ptr<RenderPassDrawQuad> Create();
RenderPass::Id renderPassId() const { return m_renderPassId; }
bool isReplica() const { return m_isReplica; }
ResourceProvider::ResourceId maskResourceId() const { return m_maskResourceId; }
const gfx::Rect& contentsChangedSinceLastFrame() const { return m_contentsChangedSinceLastFrame; }
void SetNew(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
RenderPass::Id render_pass_id,
bool is_replica,
ResourceProvider::ResourceId mask_resource_id,
gfx::Rect contents_changed_since_last_frame,
float mask_tex_coord_scale_x,
float mask_tex_coord_scale_y,
float mask_tex_coord_offset_x,
float mask_tex_coord_offset_y);
static const RenderPassDrawQuad* materialCast(const DrawQuad*);
float maskTexCoordScaleX() const { return m_maskTexCoordScaleX; }
float maskTexCoordScaleY() const { return m_maskTexCoordScaleY; }
float maskTexCoordOffsetX() const { return m_maskTexCoordOffsetX; }
float maskTexCoordOffsetY() const { return m_maskTexCoordOffsetY; }
void SetAll(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Rect visible_rect,
bool needs_blending,
RenderPass::Id render_pass_id,
bool is_replica,
ResourceProvider::ResourceId mask_resource_id,
gfx::Rect contents_changed_since_last_frame,
float mask_tex_coord_scale_x,
float mask_tex_coord_scale_y,
float mask_tex_coord_offset_x,
float mask_tex_coord_offset_y);
scoped_ptr<RenderPassDrawQuad> copy(const SharedQuadState* copiedSharedQuadState, RenderPass::Id copiedRenderPassId) const;
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;
gfx::Rect contents_changed_since_last_frame;
// TODO(danakj): Make these a tex_coord_rect like TileDrawQuad.
float mask_tex_coord_scale_x;
float mask_tex_coord_scale_y;
float mask_tex_coord_offset_x;
float mask_tex_coord_offset_y;
static const RenderPassDrawQuad* MaterialCast(const DrawQuad*);
private:
RenderPassDrawQuad(const SharedQuadState*, const gfx::Rect&, RenderPass::Id renderPassId, bool isReplica, ResourceProvider::ResourceId maskResourceId, const gfx::Rect& contentsChangedSinceLastFrame, float maskTexCoordScaleX, float maskTexCoordScaleY, float maskTexCoordOffsetX, float maskTexCoordOffsetY);
RenderPass::Id m_renderPassId;
bool m_isReplica;
ResourceProvider::ResourceId m_maskResourceId;
gfx::Rect m_contentsChangedSinceLastFrame;
float m_maskTexCoordScaleX;
float m_maskTexCoordScaleY;
float m_maskTexCoordOffsetX;
float m_maskTexCoordOffsetY;
RenderPassDrawQuad();
};
}

5
cc/render_pass_unittest.cc

@ -62,7 +62,10 @@ TEST(RenderPassTest, copyShouldBeIdenticalExceptIdAndQuads)
// Stick a quad in the pass, this should not get copied.
pass->sharedQuadStateList().append(SharedQuadState::create(WebTransformationMatrix(), gfx::Rect(), gfx::Rect(), 1));
pass->quadList().append(CheckerboardDrawQuad::create(pass->sharedQuadStateList().last(), gfx::Rect(), SkColor()).PassAs<DrawQuad>());
scoped_ptr<CheckerboardDrawQuad> checkerboardQuad = CheckerboardDrawQuad::Create();
checkerboardQuad->SetNew(pass->sharedQuadStateList().last(), gfx::Rect(), SkColor());
pass->quadList().append(checkerboardQuad.PassAs<DrawQuad>());
RenderPass::Id newId(63, 4);

10
cc/render_surface_impl.cc

@ -203,7 +203,9 @@ void RenderSurfaceImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQ
if (m_owningLayer->showDebugBorders()) {
SkColor color = forReplica ? DebugColors::SurfaceReplicaBorderColor() : DebugColors::SurfaceBorderColor();
float width = forReplica ? DebugColors::SurfaceReplicaBorderWidth(m_owningLayer->layerTreeHostImpl()) : DebugColors::SurfaceBorderWidth(m_owningLayer->layerTreeHostImpl());
quadSink.append(DebugBorderDrawQuad::create(sharedQuadState, contentRect(), color, width).PassAs<DrawQuad>(), appendQuadsData);
scoped_ptr<DebugBorderDrawQuad> debugBorderQuad = DebugBorderDrawQuad::Create();
debugBorderQuad->SetNew(sharedQuadState, contentRect(), color, width);
quadSink.append(debugBorderQuad.PassAs<DrawQuad>(), appendQuadsData);
}
// FIXME: By using the same RenderSurfaceImpl for both the content and its reflection,
@ -236,8 +238,10 @@ void RenderSurfaceImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQ
ResourceProvider::ResourceId maskResourceId = maskLayer ? maskLayer->contentsResourceId() : 0;
gfx::Rect contentsChangedSinceLastFrame = contentsChanged() ? m_contentRect : gfx::Rect();
quadSink.append(RenderPassDrawQuad::create(sharedQuadState, contentRect(), renderPassId, forReplica, maskResourceId, contentsChangedSinceLastFrame,
maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY).PassAs<DrawQuad>(), appendQuadsData);
scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
quad->SetNew(sharedQuadState, contentRect(), renderPassId, forReplica, maskResourceId, contentsChangedSinceLastFrame,
maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY);
quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
}
} // namespace cc

11
cc/scrollbar_layer_impl.cc

@ -97,7 +97,8 @@ void ScrollbarLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& append
if (m_thumbResourceId && !thumbRect.isEmpty()) {
gfx::Rect quadRect(scrollbarLayerRectToContentRect(thumbRect));
gfx::Rect opaqueRect;
scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_thumbResourceId, premultipledAlpha, uvRect, flipped);
scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_thumbResourceId, premultipledAlpha, uvRect, flipped);
quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
}
@ -108,7 +109,9 @@ void ScrollbarLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& append
if (m_foreTrackResourceId && !foreTrackRect.isEmpty()) {
gfx::Rect quadRect(scrollbarLayerRectToContentRect(foreTrackRect));
gfx::Rect opaqueRect(contentsOpaque() ? quadRect : gfx::Rect());
quadSink.append(TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_foreTrackResourceId, premultipledAlpha, toUVRect(foreTrackRect, boundsRect), flipped).PassAs<DrawQuad>(), appendQuadsData);
scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_foreTrackResourceId, premultipledAlpha, toUVRect(foreTrackRect, boundsRect), flipped);
quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
}
// Order matters here: since the back track texture is being drawn to the entire contents rect, we must append it after the thumb and
@ -116,7 +119,9 @@ void ScrollbarLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& append
if (!contentBoundsRect.IsEmpty()) {
gfx::Rect quadRect(contentBoundsRect);
gfx::Rect opaqueRect(contentsOpaque() ? quadRect : gfx::Rect());
quadSink.append(TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_backTrackResourceId, premultipledAlpha, uvRect, flipped).PassAs<DrawQuad>(), appendQuadsData);
scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_backTrackResourceId, premultipledAlpha, uvRect, flipped);
quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
}
}

50
cc/software_renderer.cc

@ -189,19 +189,19 @@ void SoftwareRenderer::drawQuad(DrawingFrame& frame, const DrawQuad* quad)
switch (quad->material) {
case DrawQuad::DEBUG_BORDER:
drawDebugBorderQuad(frame, DebugBorderDrawQuad::materialCast(quad));
drawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad));
break;
case DrawQuad::SOLID_COLOR:
drawSolidColorQuad(frame, SolidColorDrawQuad::materialCast(quad));
drawSolidColorQuad(frame, SolidColorDrawQuad::MaterialCast(quad));
break;
case DrawQuad::TEXTURE_CONTENT:
drawTextureQuad(frame, TextureDrawQuad::materialCast(quad));
drawTextureQuad(frame, TextureDrawQuad::MaterialCast(quad));
break;
case DrawQuad::TILED_CONTENT:
drawTileQuad(frame, TileDrawQuad::materialCast(quad));
drawTileQuad(frame, TileDrawQuad::MaterialCast(quad));
break;
case DrawQuad::RENDER_PASS:
drawRenderPassQuad(frame, RenderPassDrawQuad::materialCast(quad));
drawRenderPassQuad(frame, RenderPassDrawQuad::MaterialCast(quad));
break;
default:
drawUnsupportedQuad(frame, quad);
@ -220,33 +220,33 @@ void SoftwareRenderer::drawDebugBorderQuad(const DrawingFrame& frame, const Debu
m_skCurrentCanvas->getTotalMatrix().mapPoints(transformedVertices, vertices, 4);
m_skCurrentCanvas->resetMatrix();
m_skCurrentPaint.setColor(quad->color());
m_skCurrentPaint.setAlpha(quad->opacity() * SkColorGetA(quad->color()));
m_skCurrentPaint.setColor(quad->color);
m_skCurrentPaint.setAlpha(quad->opacity() * SkColorGetA(quad->color));
m_skCurrentPaint.setStyle(SkPaint::kStroke_Style);
m_skCurrentPaint.setStrokeWidth(quad->width());
m_skCurrentPaint.setStrokeWidth(quad->width);
m_skCurrentCanvas->drawPoints(SkCanvas::kPolygon_PointMode, 4, transformedVertices, m_skCurrentPaint);
}
void SoftwareRenderer::drawSolidColorQuad(const DrawingFrame& frame, const SolidColorDrawQuad* quad)
{
m_skCurrentPaint.setColor(quad->color());
m_skCurrentPaint.setAlpha(quad->opacity() * SkColorGetA(quad->color()));
m_skCurrentPaint.setColor(quad->color);
m_skCurrentPaint.setAlpha(quad->opacity() * SkColorGetA(quad->color));
m_skCurrentCanvas->drawRect(gfx::RectFToSkRect(quadVertexRect()), m_skCurrentPaint);
}
void SoftwareRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureDrawQuad* quad)
{
if (!isSoftwareResource(quad->resourceId())) {
if (!isSoftwareResource(quad->resource_id)) {
drawUnsupportedQuad(frame, quad);
return;
}
// FIXME: Add support for non-premultiplied alpha.
ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, quad->resourceId());
ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, quad->resource_id);
const SkBitmap* bitmap = lock.skBitmap();
gfx::RectF uvRect = gfx::ScaleRect(quad->uvRect(), bitmap->width(), bitmap->height());
gfx::RectF uvRect = gfx::ScaleRect(quad->uv_rect, bitmap->width(), bitmap->height());
SkRect skUvRect = gfx::RectFToSkRect(uvRect);
if (quad->flipped())
if (quad->flipped)
m_skCurrentCanvas->scale(1, -1);
m_skCurrentCanvas->drawBitmapRectToRect(*bitmap, &skUvRect,
gfx::RectFToSkRect(quadVertexRect()),
@ -255,10 +255,10 @@ void SoftwareRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureD
void SoftwareRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* quad)
{
DCHECK(isSoftwareResource(quad->resourceId()));
ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, quad->resourceId());
DCHECK(isSoftwareResource(quad->resource_id));
ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, quad->resource_id);
SkRect uvRect = gfx::RectFToSkRect(quad->texCoordRect());
SkRect uvRect = gfx::RectFToSkRect(quad->tex_coord_rect);
m_skCurrentPaint.setFilterBitmap(true);
m_skCurrentCanvas->drawBitmapRectToRect(*lock.skBitmap(), &uvRect,
gfx::RectFToSkRect(quadVertexRect()),
@ -267,11 +267,11 @@ void SoftwareRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQua
void SoftwareRenderer::drawRenderPassQuad(const DrawingFrame& frame, const RenderPassDrawQuad* quad)
{
CachedResource* contentTexture = m_renderPassTextures.get(quad->renderPassId());
CachedResource* contentTexture = m_renderPassTextures.get(quad->render_pass_id);
if (!contentTexture || !contentTexture->id())
return;
const RenderPass* renderPass = frame.renderPassesById->get(quad->renderPassId());
const RenderPass* renderPass = frame.renderPassesById->get(quad->render_pass_id);
DCHECK(renderPass);
if (!renderPass)
return;
@ -299,16 +299,16 @@ void SoftwareRenderer::drawRenderPassQuad(const DrawingFrame& frame, const Rende
if (filter)
m_skCurrentPaint.setImageFilter(filter);
if (quad->maskResourceId()) {
ResourceProvider::ScopedReadLockSoftware maskLock(m_resourceProvider, quad->maskResourceId());
if (quad->mask_resource_id) {
ResourceProvider::ScopedReadLockSoftware maskLock(m_resourceProvider, quad->mask_resource_id);
const SkBitmap* mask = maskLock.skBitmap();
SkRect maskRect = SkRect::MakeXYWH(
quad->maskTexCoordOffsetX() * mask->width(),
quad->maskTexCoordOffsetY() * mask->height(),
quad->maskTexCoordScaleX() * mask->width(),
quad->maskTexCoordScaleY() * mask->height());
quad->mask_tex_coord_offset_x * mask->width(),
quad->mask_tex_coord_offset_y * mask->height(),
quad->mask_tex_coord_scale_x * mask->width(),
quad->mask_tex_coord_scale_y * mask->height());
SkMatrix maskMat;
maskMat.setRectToRect(maskRect, destRect, SkMatrix::kFill_ScaleToFit);

20
cc/software_renderer_unittest.cc

@ -69,10 +69,12 @@ TEST_F(SoftwareRendererTest, solidColorQuad)
scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::create(WebTransformationMatrix(), outerRect, outerRect, 1.0);
RenderPass::Id rootRenderPassId = RenderPass::Id(1, 1);
scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::create(rootRenderPassId, outerRect, WebTransformationMatrix());
scoped_ptr<DrawQuad> outerQuad = SolidColorDrawQuad::create(sharedQuadState.get(), outerRect, SK_ColorYELLOW).PassAs<DrawQuad>();
scoped_ptr<DrawQuad> innerQuad = SolidColorDrawQuad::create(sharedQuadState.get(), innerRect, SK_ColorCYAN).PassAs<DrawQuad>();
rootRenderPass->appendQuad(innerQuad.Pass());
rootRenderPass->appendQuad(outerQuad.Pass());
scoped_ptr<SolidColorDrawQuad> outerQuad = SolidColorDrawQuad::Create();
outerQuad->SetNew(sharedQuadState.get(), outerRect, SK_ColorYELLOW);
scoped_ptr<SolidColorDrawQuad> innerQuad = SolidColorDrawQuad::Create();
innerQuad->SetNew(sharedQuadState.get(), innerRect, SK_ColorCYAN);
rootRenderPass->appendQuad(innerQuad.PassAs<DrawQuad>());
rootRenderPass->appendQuad(outerQuad.PassAs<DrawQuad>());
RenderPassList list;
RenderPassIdHashMap hashmap;
@ -126,10 +128,12 @@ TEST_F(SoftwareRendererTest, tileQuad)
scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::create(WebTransformationMatrix(), outerRect, outerRect, 1.0);
RenderPass::Id rootRenderPassId = RenderPass::Id(1, 1);
scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::create(rootRenderPassId, gfx::Rect(gfx::Point(), deviceViewportSize()), WebTransformationMatrix());
scoped_ptr<DrawQuad> outerQuad = TileDrawQuad::create(sharedQuadState.get(), outerRect, outerRect, resourceYellow, gfx::RectF(gfx::PointF(), outerSize), outerSize, false, false, false, false, false).PassAs<DrawQuad>();
scoped_ptr<DrawQuad> innerQuad = TileDrawQuad::create(sharedQuadState.get(), innerRect, innerRect, resourceCyan, gfx::RectF(gfx::PointF(), innerSize), innerSize, false, false, false, false, false).PassAs<DrawQuad>();
rootRenderPass->appendQuad(innerQuad.Pass());
rootRenderPass->appendQuad(outerQuad.Pass());
scoped_ptr<TileDrawQuad> outerQuad = TileDrawQuad::Create();
outerQuad->SetNew(sharedQuadState.get(), outerRect, outerRect, resourceYellow, gfx::RectF(gfx::PointF(), outerSize), outerSize, false, false, false, false, false);
scoped_ptr<TileDrawQuad> innerQuad = TileDrawQuad::Create();
innerQuad->SetNew(sharedQuadState.get(), innerRect, innerRect, resourceCyan, gfx::RectF(gfx::PointF(), innerSize), innerSize, false, false, false, false, false);
rootRenderPass->appendQuad(innerQuad.PassAs<DrawQuad>());
rootRenderPass->appendQuad(outerQuad.PassAs<DrawQuad>());
RenderPassList list;
RenderPassIdHashMap hashmap;

42
cc/solid_color_draw_quad.cc

@ -8,24 +8,38 @@
namespace cc {
scoped_ptr<SolidColorDrawQuad> SolidColorDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, SkColor color)
{
return make_scoped_ptr(new SolidColorDrawQuad(sharedQuadState, quadRect, color));
SolidColorDrawQuad::SolidColorDrawQuad() : color(0) {}
scoped_ptr<SolidColorDrawQuad> SolidColorDrawQuad::Create() {
return make_scoped_ptr(new SolidColorDrawQuad);
}
SolidColorDrawQuad::SolidColorDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, SkColor color)
: m_color(color)
{
gfx::Rect opaqueRect = SkColorGetA(m_color) == 255 ? quadRect : gfx::Rect();
gfx::Rect visibleRect = quadRect;
bool needsBlending = false;
DrawQuad::SetAll(sharedQuadState, DrawQuad::SOLID_COLOR, quadRect, opaqueRect, visibleRect, needsBlending);
void SolidColorDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
SkColor color) {
gfx::Rect opaque_rect = SkColorGetA(color) == 255 ? rect : gfx::Rect();
gfx::Rect visible_rect = rect;
bool needs_blending = false;
DrawQuad::SetAll(shared_quad_state, DrawQuad::SOLID_COLOR, rect, opaque_rect,
visible_rect, needs_blending);
this->color = color;
}
const SolidColorDrawQuad* SolidColorDrawQuad::materialCast(const DrawQuad* quad)
{
DCHECK(quad->material == DrawQuad::SOLID_COLOR);
return static_cast<const SolidColorDrawQuad*>(quad);
void SolidColorDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Rect visible_rect,
bool needs_blending,
SkColor color) {
DrawQuad::SetAll(shared_quad_state, DrawQuad::SOLID_COLOR, rect, opaque_rect,
visible_rect, needs_blending);
this->color = color;
}
const SolidColorDrawQuad* SolidColorDrawQuad::MaterialCast(
const DrawQuad* quad) {
DCHECK(quad->material == DrawQuad::SOLID_COLOR);
return static_cast<const SolidColorDrawQuad*>(quad);
}
} // namespacec cc

23
cc/solid_color_draw_quad.h

@ -13,16 +13,25 @@
namespace cc {
class CC_EXPORT SolidColorDrawQuad : public DrawQuad {
public:
static scoped_ptr<SolidColorDrawQuad> create(const SharedQuadState*, const gfx::Rect&, SkColor);
public:
static scoped_ptr<SolidColorDrawQuad> Create();
SkColor color() const { return m_color; };
void SetNew(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
SkColor color);
static const SolidColorDrawQuad* materialCast(const DrawQuad*);
private:
SolidColorDrawQuad(const SharedQuadState*, const gfx::Rect&, SkColor);
void SetAll(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Rect visible_rect,
bool needs_blending,
SkColor color);
SkColor m_color;
SkColor color;
static const SolidColorDrawQuad* MaterialCast(const DrawQuad*);
private:
SolidColorDrawQuad();
};
}

4
cc/solid_color_layer_impl.cc

@ -33,7 +33,9 @@ void SolidColorLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appen
for (int x = 0; x < width; x += m_tileSize) {
for (int y = 0; y < height; y += m_tileSize) {
gfx::Rect solidTileRect(x, y, std::min(width - x, m_tileSize), std::min(height - y, m_tileSize));
quadSink.append(SolidColorDrawQuad::create(sharedQuadState, solidTileRect, backgroundColor()).PassAs<DrawQuad>(), appendQuadsData);
scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
quad->SetNew(sharedQuadState, solidTileRect, backgroundColor());
quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
}
}
}

4
cc/solid_color_layer_impl_unittest.cc

@ -57,7 +57,7 @@ TEST(SolidColorLayerImplTest, verifyCorrectBackgroundColorInQuad)
layer->appendQuads(quadCuller, data);
ASSERT_EQ(quadCuller.quadList().size(), 1U);
EXPECT_EQ(SolidColorDrawQuad::materialCast(quadCuller.quadList()[0])->color(), testColor);
EXPECT_EQ(SolidColorDrawQuad::MaterialCast(quadCuller.quadList()[0])->color, testColor);
}
TEST(SolidColorLayerImplTest, verifyCorrectOpacityInQuad)
@ -80,7 +80,7 @@ TEST(SolidColorLayerImplTest, verifyCorrectOpacityInQuad)
layer->appendQuads(quadCuller, data);
ASSERT_EQ(quadCuller.quadList().size(), 1U);
EXPECT_EQ(opacity, SolidColorDrawQuad::materialCast(quadCuller.quadList()[0])->opacity());
EXPECT_EQ(opacity, SolidColorDrawQuad::MaterialCast(quadCuller.quadList()[0])->opacity());
}
TEST(SolidColorLayerImplTest, verifyOpaqueRect)

46
cc/stream_video_draw_quad.cc

@ -8,24 +8,42 @@
namespace cc {
scoped_ptr<StreamVideoDrawQuad> StreamVideoDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned textureId, const WebKit::WebTransformationMatrix& matrix)
{
return make_scoped_ptr(new StreamVideoDrawQuad(sharedQuadState, quadRect, opaqueRect, textureId, matrix));
StreamVideoDrawQuad::StreamVideoDrawQuad() : texture_id(0) {}
scoped_ptr<StreamVideoDrawQuad> StreamVideoDrawQuad::Create() {
return make_scoped_ptr(new StreamVideoDrawQuad);
}
StreamVideoDrawQuad::StreamVideoDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned textureId, const WebKit::WebTransformationMatrix& matrix)
: m_textureId(textureId)
, m_matrix(matrix)
{
gfx::Rect visibleRect = quadRect;
bool needsBlending = false;
DrawQuad::SetAll(sharedQuadState, DrawQuad::STREAM_VIDEO_CONTENT, quadRect, opaqueRect, visibleRect, needsBlending);
void StreamVideoDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
unsigned texture_id,
const WebKit::WebTransformationMatrix& matrix) {
gfx::Rect visible_rect = rect;
bool needs_blending = false;
DrawQuad::SetAll(shared_quad_state, DrawQuad::STREAM_VIDEO_CONTENT, rect,
opaque_rect, visible_rect, needs_blending);
this->texture_id = texture_id;
this->matrix = matrix;
}
const StreamVideoDrawQuad* StreamVideoDrawQuad::materialCast(const DrawQuad* quad)
{
DCHECK(quad->material == DrawQuad::STREAM_VIDEO_CONTENT);
return static_cast<const StreamVideoDrawQuad*>(quad);
void StreamVideoDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Rect visible_rect,
bool needs_blending,
unsigned texture_id,
const WebKit::WebTransformationMatrix& matrix) {
DrawQuad::SetAll(shared_quad_state, DrawQuad::STREAM_VIDEO_CONTENT, rect,
opaque_rect, visible_rect, needs_blending);
this->texture_id = texture_id;
this->matrix = matrix;
}
const StreamVideoDrawQuad* StreamVideoDrawQuad::MaterialCast(
const DrawQuad* quad) {
DCHECK(quad->material == DrawQuad::STREAM_VIDEO_CONTENT);
return static_cast<const StreamVideoDrawQuad*>(quad);
}
} // namespace cc

29
cc/stream_video_draw_quad.h

@ -13,18 +13,29 @@
namespace cc {
class CC_EXPORT StreamVideoDrawQuad : public DrawQuad {
public:
static scoped_ptr<StreamVideoDrawQuad> create(const SharedQuadState*, const gfx::Rect&, const gfx::Rect& opaqueRect, unsigned textureId, const WebKit::WebTransformationMatrix&);
public:
static scoped_ptr<StreamVideoDrawQuad> Create();
unsigned textureId() const { return m_textureId; }
const WebKit::WebTransformationMatrix& matrix() const { return m_matrix; }
void SetNew(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
unsigned texture_id,
const WebKit::WebTransformationMatrix& matrix);
static const StreamVideoDrawQuad* materialCast(const DrawQuad*);
private:
StreamVideoDrawQuad(const SharedQuadState*, const gfx::Rect&, const gfx::Rect& opaqueRect, unsigned textureId, const WebKit::WebTransformationMatrix&);
void SetAll(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Rect visible_rect,
bool needs_blending,
unsigned texture_id,
const WebKit::WebTransformationMatrix& matrix);
unsigned m_textureId;
WebKit::WebTransformationMatrix m_matrix;
unsigned texture_id;
WebKit::WebTransformationMatrix matrix;
static const StreamVideoDrawQuad* MaterialCast(const DrawQuad*);
private:
StreamVideoDrawQuad();
};
}

42
cc/test/render_pass_test_common.cc

@ -29,18 +29,37 @@ void TestRenderPass::appendOneOfEveryQuadType(cc::ResourceProvider* resourceProv
cc::ResourceProvider::ResourceId textureResource = resourceProvider->createResourceFromExternalTexture(1);
scoped_ptr<cc::SharedQuadState> sharedState = cc::SharedQuadState::create(WebTransformationMatrix(), rect, rect, 1);
appendQuad(cc::CheckerboardDrawQuad::create(sharedState.get(), rect, SK_ColorRED).PassAs<DrawQuad>());
appendQuad(cc::DebugBorderDrawQuad::create(sharedState.get(), rect, SK_ColorRED, 1).Pass().PassAs<DrawQuad>());
appendQuad(cc::IOSurfaceDrawQuad::create(sharedState.get(), rect, opaqueRect, gfx::Size(50, 50), 1, cc::IOSurfaceDrawQuad::Flipped).PassAs<DrawQuad>());
scoped_ptr<cc::CheckerboardDrawQuad> checkerboardQuad = cc::CheckerboardDrawQuad::Create();
checkerboardQuad->SetNew(sharedState.get(), rect, SK_ColorRED);
appendQuad(checkerboardQuad.PassAs<DrawQuad>());
cc::RenderPass::Id passId(1, 1);
appendQuad(cc::RenderPassDrawQuad::create(sharedState.get(), rect, passId, false, 0, rect, 0, 0, 0, 0).PassAs<DrawQuad>());
scoped_ptr<cc::DebugBorderDrawQuad> debugBorderQuad = cc::DebugBorderDrawQuad::Create();
debugBorderQuad->SetNew(sharedState.get(), rect, SK_ColorRED, 1);
appendQuad(debugBorderQuad.PassAs<DrawQuad>());
appendQuad(cc::SolidColorDrawQuad::create(sharedState.get(), rect, SK_ColorRED).PassAs<DrawQuad>());
appendQuad(cc::StreamVideoDrawQuad::create(sharedState.get(), rect, opaqueRect, 1, WebKit::WebTransformationMatrix()).PassAs<DrawQuad>());
appendQuad(cc::TextureDrawQuad::create(sharedState.get(), rect, opaqueRect, textureResource, false, rect, false).PassAs<DrawQuad>());
scoped_ptr<cc::IOSurfaceDrawQuad> ioSurfaceQuad = cc::IOSurfaceDrawQuad::Create();
ioSurfaceQuad->SetNew(sharedState.get(), rect, opaqueRect, gfx::Size(50, 50), 1, cc::IOSurfaceDrawQuad::FLIPPED);
appendQuad(ioSurfaceQuad.PassAs<DrawQuad>());
appendQuad(cc::TileDrawQuad::create(sharedState.get(), rect, opaqueRect, textureResource, gfx::RectF(0, 0, 100, 100), gfx::Size(100, 100), false, false, false, false, false).PassAs<DrawQuad>());
scoped_ptr<cc::RenderPassDrawQuad> renderPassQuad = cc::RenderPassDrawQuad::Create();
renderPassQuad->SetNew(sharedState.get(), rect, cc::RenderPass::Id(1, 1), false, 0, rect, 0, 0, 0, 0);
appendQuad(renderPassQuad.PassAs<DrawQuad>());
scoped_ptr<cc::SolidColorDrawQuad> solidColorQuad = cc::SolidColorDrawQuad::Create();
solidColorQuad->SetNew(sharedState.get(), rect, SK_ColorRED);
appendQuad(solidColorQuad.PassAs<DrawQuad>());
scoped_ptr<cc::StreamVideoDrawQuad> streamVideoQuad = cc::StreamVideoDrawQuad::Create();
streamVideoQuad->SetNew(sharedState.get(), rect, opaqueRect, 1, WebKit::WebTransformationMatrix());
appendQuad(streamVideoQuad.PassAs<DrawQuad>());
scoped_ptr<cc::TextureDrawQuad> textureQuad = cc::TextureDrawQuad::Create();
textureQuad->SetNew(sharedState.get(), rect, opaqueRect, textureResource, false, rect, false);
appendQuad(textureQuad.PassAs<DrawQuad>());
scoped_ptr<cc::TileDrawQuad> tileQuad = cc::TileDrawQuad::Create();
tileQuad->SetNew(sharedState.get(), rect, opaqueRect, textureResource, gfx::RectF(0, 0, 100, 100), gfx::Size(100, 100), false, false, false, false, false);
appendQuad(tileQuad.PassAs<DrawQuad>());
cc::VideoLayerImpl::FramePlane planes[3];
for (int i = 0; i < 3; ++i) {
@ -48,7 +67,10 @@ void TestRenderPass::appendOneOfEveryQuadType(cc::ResourceProvider* resourceProv
planes[i].size = gfx::Size(100, 100);
planes[i].format = GL_LUMINANCE;
}
appendQuad(cc::YUVVideoDrawQuad::create(sharedState.get(), rect, opaqueRect, gfx::Size(100, 100), planes[0], planes[1], planes[2]).PassAs<DrawQuad>());
scoped_ptr<cc::YUVVideoDrawQuad> yuvQuad = cc::YUVVideoDrawQuad::Create();
yuvQuad->SetNew(sharedState.get(), rect, opaqueRect, gfx::Size(100, 100), planes[0], planes[1], planes[2]);
appendQuad(yuvQuad.PassAs<DrawQuad>());
appendSharedQuadState(sharedState.Pass());
}

60
cc/texture_draw_quad.cc

@ -8,26 +8,54 @@
namespace cc {
scoped_ptr<TextureDrawQuad> TextureDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, bool premultipliedAlpha, const gfx::RectF& uvRect, bool flipped)
{
return make_scoped_ptr(new TextureDrawQuad(sharedQuadState, quadRect, opaqueRect, resourceId, premultipliedAlpha, uvRect, flipped));
TextureDrawQuad::TextureDrawQuad()
: resource_id(0),
premultiplied_alpha(false),
flipped(false) {
}
TextureDrawQuad::TextureDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, bool premultipliedAlpha, const gfx::RectF& uvRect, bool flipped)
: m_resourceId(resourceId)
, m_premultipliedAlpha(premultipliedAlpha)
, m_uvRect(uvRect)
, m_flipped(flipped)
{
gfx::Rect visibleRect = quadRect;
bool needsBlending = false;
DrawQuad::SetAll(sharedQuadState, DrawQuad::TEXTURE_CONTENT, quadRect, opaqueRect, visibleRect, needsBlending);
scoped_ptr<TextureDrawQuad> TextureDrawQuad::Create() {
return make_scoped_ptr(new TextureDrawQuad);
}
const TextureDrawQuad* TextureDrawQuad::materialCast(const DrawQuad* quad)
{
DCHECK(quad->material == DrawQuad::TEXTURE_CONTENT);
return static_cast<const TextureDrawQuad*>(quad);
void TextureDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
unsigned resource_id,
bool premultiplied_alpha,
const gfx::RectF& uv_rect,
bool flipped) {
gfx::Rect visible_rect = rect;
bool needs_blending = false;
DrawQuad::SetAll(shared_quad_state, DrawQuad::TEXTURE_CONTENT, rect,
opaque_rect, visible_rect, needs_blending);
this->resource_id = resource_id;
this->premultiplied_alpha = premultiplied_alpha;
this->uv_rect = uv_rect;
this->flipped = flipped;
}
void TextureDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Rect visible_rect,
bool needs_blending,
unsigned resource_id,
bool premultiplied_alpha,
const gfx::RectF& uv_rect,
bool flipped) {
DrawQuad::SetAll(shared_quad_state, DrawQuad::TEXTURE_CONTENT, rect,
opaque_rect, visible_rect, needs_blending);
this->resource_id = resource_id;
this->premultiplied_alpha = premultiplied_alpha;
this->uv_rect = uv_rect;
this->flipped = flipped;
}
const TextureDrawQuad* TextureDrawQuad::MaterialCast(
const DrawQuad* quad) {
DCHECK(quad->material == DrawQuad::TEXTURE_CONTENT);
return static_cast<const TextureDrawQuad*>(quad);
}
} // namespace cc

39
cc/texture_draw_quad.h

@ -13,22 +13,35 @@
namespace cc {
class CC_EXPORT TextureDrawQuad : public DrawQuad {
public:
static scoped_ptr<TextureDrawQuad> create(const SharedQuadState*, const gfx::Rect&, const gfx::Rect& opaqueRect, unsigned resourceId, bool premultipliedAlpha, const gfx::RectF& uvRect, bool flipped);
gfx::RectF uvRect() const { return m_uvRect; }
public:
static scoped_ptr<TextureDrawQuad> Create();
unsigned resourceId() const { return m_resourceId; }
bool premultipliedAlpha() const { return m_premultipliedAlpha; }
bool flipped() const { return m_flipped; }
void SetNew(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
unsigned resource_id,
bool premultiplied_alpha,
const gfx::RectF& uv_rect,
bool flipped);
static const TextureDrawQuad* materialCast(const DrawQuad*);
private:
TextureDrawQuad(const SharedQuadState*, const gfx::Rect&, const gfx::Rect& opaqueRect, unsigned resourceId, bool premultipliedAlpha, const gfx::RectF& uvRect, bool flipped);
void SetAll(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Rect visible_rect,
bool needs_blending,
unsigned resource_id,
bool premultiplied_alpha,
const gfx::RectF& uv_rect,
bool flipped);
unsigned m_resourceId;
bool m_premultipliedAlpha;
gfx::RectF m_uvRect;
bool m_flipped;
unsigned resource_id;
bool premultiplied_alpha;
gfx::RectF uv_rect;
bool flipped;
static const TextureDrawQuad* MaterialCast(const DrawQuad*);
private:
TextureDrawQuad();
};
}

4
cc/texture_layer_impl.cc

@ -43,7 +43,9 @@ void TextureLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQu
gfx::Rect quadRect(gfx::Point(), contentBounds());
gfx::Rect opaqueRect(contentsOpaque() ? quadRect : gfx::Rect());
quadSink.append(TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_externalTextureResource, m_premultipliedAlpha, m_uvRect, m_flipped).PassAs<DrawQuad>(), appendQuadsData);
scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_externalTextureResource, m_premultipliedAlpha, m_uvRect, m_flipped);
quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
}
void TextureLayerImpl::didDraw(ResourceProvider* resourceProvider)

86
cc/tile_draw_quad.cc

@ -9,30 +9,76 @@
namespace cc {
scoped_ptr<TileDrawQuad> TileDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::RectF& texCoordRect, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA)
{
return make_scoped_ptr(new TileDrawQuad(sharedQuadState, quadRect, opaqueRect, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA));
TileDrawQuad::TileDrawQuad()
: resource_id(0),
swizzle_contents(false),
left_edge_aa(false),
top_edge_aa(false),
right_edge_aa(false),
bottom_edge_aa(false) {
}
TileDrawQuad::TileDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::RectF& texCoordRect, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA)
: m_resourceId(resourceId)
, m_texCoordRect(texCoordRect)
, m_textureSize(textureSize)
, m_swizzleContents(swizzleContents)
, m_leftEdgeAA(leftEdgeAA)
, m_topEdgeAA(topEdgeAA)
, m_rightEdgeAA(rightEdgeAA)
, m_bottomEdgeAA(bottomEdgeAA)
{
gfx::Rect visibleRect = quadRect;
bool needsBlending = isAntialiased();
DrawQuad::SetAll(sharedQuadState, DrawQuad::TILED_CONTENT, quadRect, opaqueRect, visibleRect, needsBlending);
scoped_ptr<TileDrawQuad> TileDrawQuad::Create() {
return make_scoped_ptr(new TileDrawQuad);
}
const TileDrawQuad* TileDrawQuad::materialCast(const DrawQuad* quad)
{
DCHECK(quad->material == DrawQuad::TILED_CONTENT);
return static_cast<const TileDrawQuad*>(quad);
void TileDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
unsigned resource_id,
const gfx::RectF& tex_coord_rect,
gfx::Size texture_size,
bool swizzle_contents,
bool left_edge_aa,
bool top_edge_aa,
bool right_edge_aa,
bool bottom_edge_aa) {
gfx::Rect visible_rect = rect;
bool needs_blending = false;
DrawQuad::SetAll(shared_quad_state, DrawQuad::TILED_CONTENT, rect,
opaque_rect, visible_rect, needs_blending);
this->resource_id = resource_id;
this->tex_coord_rect = tex_coord_rect;
this->texture_size = texture_size;
this->swizzle_contents = swizzle_contents;
this->left_edge_aa = left_edge_aa;
this->top_edge_aa = top_edge_aa;
this->right_edge_aa = right_edge_aa;
this->bottom_edge_aa = bottom_edge_aa;
// Override needs_blending after initializing the quad.
this->needs_blending = IsAntialiased();
}
void TileDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Rect visible_rect,
bool needs_blending,
unsigned resource_id,
const gfx::RectF& tex_coord_rect,
gfx::Size texture_size,
bool swizzle_contents,
bool left_edge_aa,
bool top_edge_aa,
bool right_edge_aa,
bool bottom_edge_aa) {
DrawQuad::SetAll(shared_quad_state, DrawQuad::TILED_CONTENT, rect,
opaque_rect, visible_rect, needs_blending);
this->resource_id = resource_id;
this->tex_coord_rect = tex_coord_rect;
this->texture_size = texture_size;
this->swizzle_contents = swizzle_contents;
this->left_edge_aa = left_edge_aa;
this->top_edge_aa = top_edge_aa;
this->right_edge_aa = right_edge_aa;
this->bottom_edge_aa = bottom_edge_aa;
}
const TileDrawQuad* TileDrawQuad::MaterialCast(
const DrawQuad* quad) {
DCHECK(quad->material == DrawQuad::TILED_CONTENT);
return static_cast<const TileDrawQuad*>(quad);
}
} // namespace cc

67
cc/tile_draw_quad.h

@ -15,35 +15,54 @@
namespace cc {
class CC_EXPORT TileDrawQuad : public DrawQuad {
public:
static scoped_ptr<TileDrawQuad> create(const SharedQuadState*, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::RectF& texCoordRect, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA);
public:
static scoped_ptr<TileDrawQuad> Create();
unsigned resourceId() const { return m_resourceId; }
gfx::RectF texCoordRect() const { return m_texCoordRect; }
gfx::Size textureSize() const { return m_textureSize; }
bool swizzleContents() const { return m_swizzleContents; }
void SetNew(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
unsigned resource_id,
const gfx::RectF& tex_coord_rect,
gfx::Size texture_size,
bool swizzle_contents,
bool left_edge_aa,
bool top_edge_aa,
bool right_edge_aa,
bool bottom_edge_aa);
// TODO(danakj): Stick the data used to compute these things in the quad
// instead so the parent compositor can decide to use AA on its own.
bool leftEdgeAA() const { return m_leftEdgeAA; }
bool topEdgeAA() const { return m_topEdgeAA; }
bool rightEdgeAA() const { return m_rightEdgeAA; }
bool bottomEdgeAA() const { return m_bottomEdgeAA; }
void SetAll(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Rect visible_rect,
bool needs_blending,
unsigned resource_id,
const gfx::RectF& tex_coord_rect,
gfx::Size texture_size,
bool swizzle_contents,
bool left_edge_aa,
bool top_edge_aa,
bool right_edge_aa,
bool bottom_edge_aa);
bool isAntialiased() const { return leftEdgeAA() || topEdgeAA() || rightEdgeAA() || bottomEdgeAA(); }
unsigned resource_id;
gfx::RectF tex_coord_rect;
gfx::Size texture_size;
bool swizzle_contents;
static const TileDrawQuad* materialCast(const DrawQuad*);
private:
TileDrawQuad(const SharedQuadState*, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::RectF& texCoordRect, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA);
// TODO(danakj): Stick the data used to compute these things in the quad
// instead so the parent compositor can decide to use AA on its own.
bool left_edge_aa;
bool top_edge_aa;
bool right_edge_aa;
bool bottom_edge_aa;
unsigned m_resourceId;
gfx::RectF m_texCoordRect;
gfx::Size m_textureSize;
bool m_swizzleContents;
bool m_leftEdgeAA;
bool m_topEdgeAA;
bool m_rightEdgeAA;
bool m_bottomEdgeAA;
bool IsAntialiased() const {
return left_edge_aa || top_edge_aa || right_edge_aa || bottom_edge_aa;
}
static const TileDrawQuad* MaterialCast(const DrawQuad*);
private:
TileDrawQuad();
};
}

19
cc/tiled_layer_impl.cc

@ -133,7 +133,9 @@ void TiledLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad
borderColor = DebugColors::TileBorderColor();
borderWidth = DebugColors::TileBorderWidth(layerTreeHostImpl());
}
quadSink.append(DebugBorderDrawQuad::create(sharedQuadState, tileRect, borderColor, borderWidth).PassAs<DrawQuad>(), appendQuadsData);
scoped_ptr<DebugBorderDrawQuad> debugBorderQuad = DebugBorderDrawQuad::Create();
debugBorderQuad->SetNew(sharedQuadState, tileRect, borderColor, borderWidth);
quadSink.append(debugBorderQuad.PassAs<DrawQuad>(), appendQuadsData);
}
}
}
@ -160,9 +162,14 @@ void TiledLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad
else
checkerColor = kTileCheckerboardColor;
appendQuadsData.hadMissingTiles |= quadSink.append(CheckerboardDrawQuad::create(sharedQuadState, tileRect, checkerColor).PassAs<DrawQuad>(), appendQuadsData);
} else
appendQuadsData.hadMissingTiles |= quadSink.append(SolidColorDrawQuad::create(sharedQuadState, tileRect, backgroundColor()).PassAs<DrawQuad>(), appendQuadsData);
scoped_ptr<CheckerboardDrawQuad> checkerboardQuad = CheckerboardDrawQuad::Create();
checkerboardQuad->SetNew(sharedQuadState, tileRect, checkerColor);
appendQuadsData.hadMissingTiles |= quadSink.append(checkerboardQuad.PassAs<DrawQuad>(), appendQuadsData);
} else {
scoped_ptr<SolidColorDrawQuad> solidColorQuad = SolidColorDrawQuad::Create();
solidColorQuad->SetNew(sharedQuadState, tileRect, backgroundColor());
appendQuadsData.hadMissingTiles |= quadSink.append(solidColorQuad.PassAs<DrawQuad>(), appendQuadsData);
}
continue;
}
@ -188,7 +195,9 @@ void TiledLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad
bool rightEdgeAA = i == m_tiler->numTilesX() - 1 && useAA;
bool bottomEdgeAA = j == m_tiler->numTilesY() - 1 && useAA;
quadSink.append(TileDrawQuad::create(sharedQuadState, tileRect, tileOpaqueRect, tile->resourceId(), texCoordRect, textureSize, tile->contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA).PassAs<DrawQuad>(), appendQuadsData);
scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
quad->SetNew(sharedQuadState, tileRect, tileOpaqueRect, tile->resourceId(), texCoordRect, textureSize, tile->contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
}
}
}

8
cc/tiled_layer_impl_unittest.cc

@ -199,11 +199,11 @@ TEST(TiledLayerImplTest, textureInfoForLayerNoBorders)
getQuads(quads, sharedStates, tileSize, layerSize, LayerTilingData::NoBorderTexels, gfx::Rect(gfx::Point(), layerSize));
for (size_t i = 0; i < quads.size(); ++i) {
const TileDrawQuad* quad = TileDrawQuad::materialCast(quads[i]);
const TileDrawQuad* quad = TileDrawQuad::MaterialCast(quads[i]);
EXPECT_NE(quad->resourceId(), 0u) << quadString << i;
EXPECT_EQ(quad->texCoordRect(), gfx::RectF(gfx::PointF(), tileSize)) << quadString << i;
EXPECT_EQ(quad->textureSize(), tileSize) << quadString << i;
EXPECT_NE(0u, quad->resource_id) << quadString << i;
EXPECT_EQ(gfx::RectF(gfx::PointF(), tileSize), quad->tex_coord_rect) << quadString << i;
EXPECT_EQ(tileSize, quad->texture_size) << quadString << i;
EXPECT_EQ(gfx::Rect(0, 0, 1, 1), quad->opaque_rect) << quadString << i;
}
}

19
cc/video_layer_impl.cc

@ -217,8 +217,8 @@ void VideoLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad
const FramePlane& uPlane = m_framePlanes[media::VideoFrame::kUPlane];
const FramePlane& vPlane = m_framePlanes[media::VideoFrame::kVPlane];
gfx::SizeF texScale(texWidthScale, texHeightScale);
scoped_ptr<YUVVideoDrawQuad> yuvVideoQuad = YUVVideoDrawQuad::create(
sharedQuadState, quadRect, opaqueRect, texScale, yPlane, uPlane, vPlane);
scoped_ptr<YUVVideoDrawQuad> yuvVideoQuad = YUVVideoDrawQuad::Create();
yuvVideoQuad->SetNew(sharedQuadState, quadRect, opaqueRect, texScale, yPlane, uPlane, vPlane);
quadSink.append(yuvVideoQuad.PassAs<DrawQuad>(), appendQuadsData);
break;
}
@ -228,7 +228,8 @@ void VideoLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad
bool premultipliedAlpha = true;
gfx::RectF uvRect(0, 0, texWidthScale, texHeightScale);
bool flipped = false;
scoped_ptr<TextureDrawQuad> textureQuad = TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, plane.resourceId, premultipliedAlpha, uvRect, flipped);
scoped_ptr<TextureDrawQuad> textureQuad = TextureDrawQuad::Create();
textureQuad->SetNew(sharedQuadState, quadRect, opaqueRect, plane.resourceId, premultipliedAlpha, uvRect, flipped);
quadSink.append(textureQuad.PassAs<DrawQuad>(), appendQuadsData);
break;
}
@ -237,13 +238,15 @@ void VideoLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad
bool premultipliedAlpha = true;
gfx::RectF uvRect(0, 0, texWidthScale, texHeightScale);
bool flipped = false;
scoped_ptr<TextureDrawQuad> textureQuad = TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_externalTextureResource, premultipliedAlpha, uvRect, flipped);
scoped_ptr<TextureDrawQuad> textureQuad = TextureDrawQuad::Create();
textureQuad->SetNew(sharedQuadState, quadRect, opaqueRect, m_externalTextureResource, premultipliedAlpha, uvRect, flipped);
quadSink.append(textureQuad.PassAs<DrawQuad>(), appendQuadsData);
break;
}
case GL_TEXTURE_RECTANGLE_ARB: {
gfx::Size visibleSize(visibleRect.width(), visibleRect.height());
scoped_ptr<IOSurfaceDrawQuad> ioSurfaceQuad = IOSurfaceDrawQuad::create(sharedQuadState, quadRect, opaqueRect, visibleSize, m_frame->texture_id(), IOSurfaceDrawQuad::Unflipped);
scoped_ptr<IOSurfaceDrawQuad> ioSurfaceQuad = IOSurfaceDrawQuad::Create();
ioSurfaceQuad->SetNew(sharedQuadState, quadRect, opaqueRect, visibleSize, m_frame->texture_id(), IOSurfaceDrawQuad::UNFLIPPED);
quadSink.append(ioSurfaceQuad.PassAs<DrawQuad>(), appendQuadsData);
break;
}
@ -251,10 +254,8 @@ void VideoLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad
// StreamTexture hardware decoder.
WebKit::WebTransformationMatrix transform(m_streamTextureMatrix);
transform.scaleNonUniform(texWidthScale, texHeightScale);
scoped_ptr<StreamVideoDrawQuad> streamVideoQuad =
StreamVideoDrawQuad::create(sharedQuadState, quadRect, opaqueRect,
m_frame->texture_id(),
transform);
scoped_ptr<StreamVideoDrawQuad> streamVideoQuad = StreamVideoDrawQuad::Create();
streamVideoQuad->SetNew(sharedQuadState, quadRect, opaqueRect, m_frame->texture_id(), transform);
quadSink.append(streamVideoQuad.PassAs<DrawQuad>(), appendQuadsData);
break;
}

73
cc/yuv_video_draw_quad.cc

@ -8,46 +8,51 @@
namespace cc {
scoped_ptr<YUVVideoDrawQuad> YUVVideoDrawQuad::create(
const SharedQuadState* sharedQuadState,
const gfx::Rect& quadRect,
const gfx::Rect& opaqueRect,
const gfx::SizeF& texScale,
const VideoLayerImpl::FramePlane& yPlane,
const VideoLayerImpl::FramePlane& uPlane,
const VideoLayerImpl::FramePlane& vPlane)
{
return make_scoped_ptr(new YUVVideoDrawQuad(sharedQuadState,
quadRect, opaqueRect, texScale,
yPlane, uPlane, vPlane));
YUVVideoDrawQuad::YUVVideoDrawQuad() {}
YUVVideoDrawQuad::~YUVVideoDrawQuad() {}
scoped_ptr<YUVVideoDrawQuad> YUVVideoDrawQuad::Create() {
return make_scoped_ptr(new YUVVideoDrawQuad);
}
YUVVideoDrawQuad::YUVVideoDrawQuad(
const SharedQuadState* sharedQuadState,
const gfx::Rect& quadRect,
const gfx::Rect& opaqueRect,
const gfx::SizeF& texScale,
const VideoLayerImpl::FramePlane& yPlane,
const VideoLayerImpl::FramePlane& uPlane,
const VideoLayerImpl::FramePlane& vPlane)
: m_texScale(texScale)
, m_yPlane(yPlane)
, m_uPlane(uPlane)
, m_vPlane(vPlane)
{
gfx::Rect visibleRect = quadRect;
bool needsBlending = false;
DrawQuad::SetAll(sharedQuadState, DrawQuad::YUV_VIDEO_CONTENT, quadRect, opaqueRect, visibleRect, needsBlending);
void YUVVideoDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::SizeF tex_scale,
const VideoLayerImpl::FramePlane& y_plane,
const VideoLayerImpl::FramePlane& u_plane,
const VideoLayerImpl::FramePlane& v_plane) {
gfx::Rect visible_rect = rect;
bool needs_blending = false;
DrawQuad::SetAll(shared_quad_state, DrawQuad::YUV_VIDEO_CONTENT, rect,
opaque_rect, visible_rect, needs_blending);
this->tex_scale = tex_scale;
this->y_plane = y_plane;
this->u_plane = u_plane;
this->v_plane = v_plane;
}
YUVVideoDrawQuad::~YUVVideoDrawQuad()
{
void YUVVideoDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Rect visible_rect,
bool needs_blending,
gfx::SizeF tex_scale,
const VideoLayerImpl::FramePlane& y_plane,
const VideoLayerImpl::FramePlane& u_plane,
const VideoLayerImpl::FramePlane& v_plane) {
DrawQuad::SetAll(shared_quad_state, DrawQuad::YUV_VIDEO_CONTENT, rect,
opaque_rect, visible_rect, needs_blending);
this->tex_scale = tex_scale;
this->y_plane = y_plane;
this->u_plane = u_plane;
this->v_plane = v_plane;
}
const YUVVideoDrawQuad* YUVVideoDrawQuad::materialCast(const DrawQuad* quad)
{
DCHECK(quad->material == DrawQuad::YUV_VIDEO_CONTENT);
return static_cast<const YUVVideoDrawQuad*>(quad);
const YUVVideoDrawQuad* YUVVideoDrawQuad::MaterialCast(
const DrawQuad* quad) {
DCHECK(quad->material == DrawQuad::YUV_VIDEO_CONTENT);
return static_cast<const YUVVideoDrawQuad*>(quad);
}
} // namespace cc

54
cc/yuv_video_draw_quad.h

@ -14,39 +14,37 @@
namespace cc {
class CC_EXPORT YUVVideoDrawQuad : public DrawQuad {
public:
static scoped_ptr<YUVVideoDrawQuad> create(
const SharedQuadState* sharedQuadState,
const gfx::Rect& quadRect,
const gfx::Rect& opaqueRect,
const gfx::SizeF& texScale,
const VideoLayerImpl::FramePlane& yPlane,
const VideoLayerImpl::FramePlane& uPlane,
const VideoLayerImpl::FramePlane& vPlane);
public:
virtual ~YUVVideoDrawQuad();
virtual ~YUVVideoDrawQuad();
static scoped_ptr<YUVVideoDrawQuad> Create();
const gfx::SizeF& texScale() const { return m_texScale; }
void SetNew(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::SizeF tex_scale,
const VideoLayerImpl::FramePlane& y_plane,
const VideoLayerImpl::FramePlane& u_plane,
const VideoLayerImpl::FramePlane& v_plane);
const VideoLayerImpl::FramePlane& yPlane() const { return m_yPlane; }
const VideoLayerImpl::FramePlane& uPlane() const { return m_uPlane; }
const VideoLayerImpl::FramePlane& vPlane() const { return m_vPlane; }
void SetAll(const SharedQuadState* shared_quad_state,
gfx::Rect rect,
gfx::Rect opaque_rect,
gfx::Rect visible_rect,
bool needs_blending,
gfx::SizeF tex_scale,
const VideoLayerImpl::FramePlane& y_plane,
const VideoLayerImpl::FramePlane& u_plane,
const VideoLayerImpl::FramePlane& v_plane);
static const YUVVideoDrawQuad* materialCast(const DrawQuad*);
private:
YUVVideoDrawQuad(
const SharedQuadState* sharedQuadState,
const gfx::Rect& quadRect,
const gfx::Rect& opaqueRect,
const gfx::SizeF& texScale,
const VideoLayerImpl::FramePlane& yPlane,
const VideoLayerImpl::FramePlane& uPlane,
const VideoLayerImpl::FramePlane& vPlane);
gfx::SizeF tex_scale;
VideoLayerImpl::FramePlane y_plane;
VideoLayerImpl::FramePlane u_plane;
VideoLayerImpl::FramePlane v_plane;
gfx::SizeF m_texScale;
VideoLayerImpl::FramePlane m_yPlane;
VideoLayerImpl::FramePlane m_uPlane;
VideoLayerImpl::FramePlane m_vPlane;
static const YUVVideoDrawQuad* MaterialCast(const DrawQuad*);
private:
YUVVideoDrawQuad();
};
}